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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        SetRequest setRequest = ; // SetRequest | 

        try {
            ApiResultSetResponse result = apiInstance.add(setRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#add");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetRequest setRequest = new SetRequest(); // SetRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        SetRequest setRequest = ; // SetRequest | 

        try {
            ApiResultSetResponse result = apiInstance.add(setRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#add");
            e.printStackTrace();
        }
    }
}

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

// 키가 없을 때 저장
[apiInstance addWith:setRequest
              completionHandler: ^(ApiResultSetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var setRequest = ; // {SetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var setRequest = new SetRequest(); // SetRequest | 

            try {
                // 키가 없을 때 저장
                ApiResultSetResponse result = apiInstance.add(setRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.add: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$setRequest = ; // SetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $setRequest = WWW::OPenAPIClient::Object::SetRequest->new(); # SetRequest | 

eval {
    my $result = $api_instance->add(setRequest => $setRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->add: $@\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.KVApi()
setRequest =  # SetRequest | 

try:
    # 키가 없을 때 저장
    api_response = api_instance.add(setRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->add: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let setRequest = ; // SetRequest

    let mut context = KVApi::Context::default();
    let result = client.add(setRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        AffixRequest affixRequest = ; // AffixRequest | 

        try {
            ApiResultSetResponse result = apiInstance.append(affixRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#append");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AffixRequest affixRequest = new AffixRequest(); // AffixRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        AffixRequest affixRequest = ; // AffixRequest | 

        try {
            ApiResultSetResponse result = apiInstance.append(affixRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#append");
            e.printStackTrace();
        }
    }
}

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

// 기존 값 뒤에 추가
[apiInstance appendWith:affixRequest
              completionHandler: ^(ApiResultSetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var affixRequest = ; // {AffixRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var affixRequest = new AffixRequest(); // AffixRequest | 

            try {
                // 기존 값 뒤에 추가
                ApiResultSetResponse result = apiInstance.append(affixRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.append: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$affixRequest = ; // AffixRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $affixRequest = WWW::OPenAPIClient::Object::AffixRequest->new(); # AffixRequest | 

eval {
    my $result = $api_instance->append(affixRequest => $affixRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->append: $@\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.KVApi()
affixRequest =  # AffixRequest | 

try:
    # 기존 값 뒤에 추가
    api_response = api_instance.append(affixRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->append: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let affixRequest = ; // AffixRequest

    let mut context = KVApi::Context::default();
    let result = client.append(affixRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        CounterRequest counterRequest = ; // CounterRequest | 

        try {
            ApiResultCounterResponse result = apiInstance.decr(counterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#decr");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CounterRequest counterRequest = new CounterRequest(); // CounterRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        CounterRequest counterRequest = ; // CounterRequest | 

        try {
            ApiResultCounterResponse result = apiInstance.decr(counterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#decr");
            e.printStackTrace();
        }
    }
}

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

// 숫자 값 감소
[apiInstance decrWith:counterRequest
              completionHandler: ^(ApiResultCounterResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var counterRequest = ; // {CounterRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var counterRequest = new CounterRequest(); // CounterRequest | 

            try {
                // 숫자 값 감소
                ApiResultCounterResponse result = apiInstance.decr(counterRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.decr: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$counterRequest = ; // CounterRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $counterRequest = WWW::OPenAPIClient::Object::CounterRequest->new(); # CounterRequest | 

eval {
    my $result = $api_instance->decr(counterRequest => $counterRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->decr: $@\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.KVApi()
counterRequest =  # CounterRequest | 

try:
    # 숫자 값 감소
    api_response = api_instance.decr(counterRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->decr: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let counterRequest = ; // CounterRequest

    let mut context = KVApi::Context::default();
    let result = client.decr(counterRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        GetRequest getRequest = ; // GetRequest | 

        try {
            ApiResultBooleanResponse result = apiInstance.delete(getRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#delete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetRequest getRequest = new GetRequest(); // GetRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        GetRequest getRequest = ; // GetRequest | 

        try {
            ApiResultBooleanResponse result = apiInstance.delete(getRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#delete");
            e.printStackTrace();
        }
    }
}

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

// 아이템 삭제
[apiInstance deleteWith:getRequest
              completionHandler: ^(ApiResultBooleanResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var getRequest = ; // {GetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var getRequest = new GetRequest(); // GetRequest | 

            try {
                // 아이템 삭제
                ApiResultBooleanResponse result = apiInstance.delete(getRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.delete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$getRequest = ; // GetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $getRequest = WWW::OPenAPIClient::Object::GetRequest->new(); # GetRequest | 

eval {
    my $result = $api_instance->delete(getRequest => $getRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->delete: $@\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.KVApi()
getRequest =  # GetRequest | 

try:
    # 아이템 삭제
    api_response = api_instance.delete(getRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->delete: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let getRequest = ; // GetRequest

    let mut context = KVApi::Context::default();
    let result = client.delete(getRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        DeleteBulkRequest deleteBulkRequest = ; // DeleteBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.deleteBulk(deleteBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#deleteBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DeleteBulkRequest deleteBulkRequest = new DeleteBulkRequest(); // DeleteBulkRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        DeleteBulkRequest deleteBulkRequest = ; // DeleteBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.deleteBulk(deleteBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#deleteBulk");
            e.printStackTrace();
        }
    }
}

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

// delete-bulk
[apiInstance deleteBulkWith:deleteBulkRequest
              completionHandler: ^(ApiResultBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var deleteBulkRequest = ; // {DeleteBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var deleteBulkRequest = new DeleteBulkRequest(); // DeleteBulkRequest | 

            try {
                // delete-bulk
                ApiResultBulkResponse result = apiInstance.deleteBulk(deleteBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.deleteBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$deleteBulkRequest = ; // DeleteBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $deleteBulkRequest = WWW::OPenAPIClient::Object::DeleteBulkRequest->new(); # DeleteBulkRequest | 

eval {
    my $result = $api_instance->deleteBulk(deleteBulkRequest => $deleteBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->deleteBulk: $@\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.KVApi()
deleteBulkRequest =  # DeleteBulkRequest | 

try:
    # delete-bulk
    api_response = api_instance.delete_bulk(deleteBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->deleteBulk: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let deleteBulkRequest = ; // DeleteBulkRequest

    let mut context = KVApi::Context::default();
    let result = client.deleteBulk(deleteBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        GetRequest getRequest = ; // GetRequest | 

        try {
            ApiResultGetResponse result = apiInstance.get(getRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#get");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetRequest getRequest = new GetRequest(); // GetRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        GetRequest getRequest = ; // GetRequest | 

        try {
            ApiResultGetResponse result = apiInstance.get(getRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#get");
            e.printStackTrace();
        }
    }
}

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

// Key-Value 조회
[apiInstance getWith:getRequest
              completionHandler: ^(ApiResultGetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var getRequest = ; // {GetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var getRequest = new GetRequest(); // GetRequest | 

            try {
                // Key-Value 조회
                ApiResultGetResponse result = apiInstance.get(getRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.get: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$getRequest = ; // GetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $getRequest = WWW::OPenAPIClient::Object::GetRequest->new(); # GetRequest | 

eval {
    my $result = $api_instance->get(getRequest => $getRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->get: $@\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.KVApi()
getRequest =  # GetRequest | 

try:
    # Key-Value 조회
    api_response = api_instance.get(getRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->get: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let getRequest = ; // GetRequest

    let mut context = KVApi::Context::default();
    let result = client.get(getRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        TouchRequest touchRequest = ; // TouchRequest | 

        try {
            ApiResultGetResponse result = apiInstance.getAndTouch(touchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#getAndTouch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TouchRequest touchRequest = new TouchRequest(); // TouchRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        TouchRequest touchRequest = ; // TouchRequest | 

        try {
            ApiResultGetResponse result = apiInstance.getAndTouch(touchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#getAndTouch");
            e.printStackTrace();
        }
    }
}

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

// 조회와 만료시간 갱신
[apiInstance getAndTouchWith:touchRequest
              completionHandler: ^(ApiResultGetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var touchRequest = ; // {TouchRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var touchRequest = new TouchRequest(); // TouchRequest | 

            try {
                // 조회와 만료시간 갱신
                ApiResultGetResponse result = apiInstance.getAndTouch(touchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.getAndTouch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$touchRequest = ; // TouchRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $touchRequest = WWW::OPenAPIClient::Object::TouchRequest->new(); # TouchRequest | 

eval {
    my $result = $api_instance->getAndTouch(touchRequest => $touchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->getAndTouch: $@\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.KVApi()
touchRequest =  # TouchRequest | 

try:
    # 조회와 만료시간 갱신
    api_response = api_instance.get_and_touch(touchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->getAndTouch: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let touchRequest = ; // TouchRequest

    let mut context = KVApi::Context::default();
    let result = client.getAndTouch(touchRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        GetBulkRequest getBulkRequest = ; // GetBulkRequest | 

        try {
            ApiResultGetBulkResponse result = apiInstance.getBulk(getBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#getBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetBulkRequest getBulkRequest = new GetBulkRequest(); // GetBulkRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        GetBulkRequest getBulkRequest = ; // GetBulkRequest | 

        try {
            ApiResultGetBulkResponse result = apiInstance.getBulk(getBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#getBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 키 조회
[apiInstance getBulkWith:getBulkRequest
              completionHandler: ^(ApiResultGetBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var getBulkRequest = ; // {GetBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var getBulkRequest = new GetBulkRequest(); // GetBulkRequest | 

            try {
                // 여러 키 조회
                ApiResultGetBulkResponse result = apiInstance.getBulk(getBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.getBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$getBulkRequest = ; // GetBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $getBulkRequest = WWW::OPenAPIClient::Object::GetBulkRequest->new(); # GetBulkRequest | 

eval {
    my $result = $api_instance->getBulk(getBulkRequest => $getBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->getBulk: $@\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.KVApi()
getBulkRequest =  # GetBulkRequest | 

try:
    # 여러 키 조회
    api_response = api_instance.get_bulk(getBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->getBulk: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let getBulkRequest = ; // GetBulkRequest

    let mut context = KVApi::Context::default();
    let result = client.getBulk(getBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        GetRequest getRequest = ; // GetRequest | 

        try {
            ApiResultGetsResponse result = apiInstance.gets(getRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#gets");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetRequest getRequest = new GetRequest(); // GetRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        GetRequest getRequest = ; // GetRequest | 

        try {
            ApiResultGetsResponse result = apiInstance.gets(getRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#gets");
            e.printStackTrace();
        }
    }
}

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

// 값과 CAS 조회
[apiInstance getsWith:getRequest
              completionHandler: ^(ApiResultGetsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var getRequest = ; // {GetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var getRequest = new GetRequest(); // GetRequest | 

            try {
                // 값과 CAS 조회
                ApiResultGetsResponse result = apiInstance.gets(getRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.gets: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$getRequest = ; // GetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $getRequest = WWW::OPenAPIClient::Object::GetRequest->new(); # GetRequest | 

eval {
    my $result = $api_instance->gets(getRequest => $getRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->gets: $@\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.KVApi()
getRequest =  # GetRequest | 

try:
    # 값과 CAS 조회
    api_response = api_instance.gets(getRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->gets: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let getRequest = ; // GetRequest

    let mut context = KVApi::Context::default();
    let result = client.gets(getRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        GetBulkRequest getBulkRequest = ; // GetBulkRequest | 

        try {
            ApiResultGetsBulkResponse result = apiInstance.getsBulk(getBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#getsBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetBulkRequest getBulkRequest = new GetBulkRequest(); // GetBulkRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        GetBulkRequest getBulkRequest = ; // GetBulkRequest | 

        try {
            ApiResultGetsBulkResponse result = apiInstance.getsBulk(getBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#getsBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 값과 CAS 조회
[apiInstance getsBulkWith:getBulkRequest
              completionHandler: ^(ApiResultGetsBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var getBulkRequest = ; // {GetBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var getBulkRequest = new GetBulkRequest(); // GetBulkRequest | 

            try {
                // 여러 값과 CAS 조회
                ApiResultGetsBulkResponse result = apiInstance.getsBulk(getBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.getsBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$getBulkRequest = ; // GetBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $getBulkRequest = WWW::OPenAPIClient::Object::GetBulkRequest->new(); # GetBulkRequest | 

eval {
    my $result = $api_instance->getsBulk(getBulkRequest => $getBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->getsBulk: $@\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.KVApi()
getBulkRequest =  # GetBulkRequest | 

try:
    # 여러 값과 CAS 조회
    api_response = api_instance.gets_bulk(getBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->getsBulk: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let getBulkRequest = ; // GetBulkRequest

    let mut context = KVApi::Context::default();
    let result = client.getsBulk(getBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        CounterRequest counterRequest = ; // CounterRequest | 

        try {
            ApiResultCounterResponse result = apiInstance.incr(counterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#incr");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CounterRequest counterRequest = new CounterRequest(); // CounterRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        CounterRequest counterRequest = ; // CounterRequest | 

        try {
            ApiResultCounterResponse result = apiInstance.incr(counterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#incr");
            e.printStackTrace();
        }
    }
}

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

// 숫자 값 증가
[apiInstance incrWith:counterRequest
              completionHandler: ^(ApiResultCounterResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var counterRequest = ; // {CounterRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var counterRequest = new CounterRequest(); // CounterRequest | 

            try {
                // 숫자 값 증가
                ApiResultCounterResponse result = apiInstance.incr(counterRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.incr: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$counterRequest = ; // CounterRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $counterRequest = WWW::OPenAPIClient::Object::CounterRequest->new(); # CounterRequest | 

eval {
    my $result = $api_instance->incr(counterRequest => $counterRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->incr: $@\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.KVApi()
counterRequest =  # CounterRequest | 

try:
    # 숫자 값 증가
    api_response = api_instance.incr(counterRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->incr: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let counterRequest = ; // CounterRequest

    let mut context = KVApi::Context::default();
    let result = client.incr(counterRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        AffixRequest affixRequest = ; // AffixRequest | 

        try {
            ApiResultSetResponse result = apiInstance.prepend(affixRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#prepend");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AffixRequest affixRequest = new AffixRequest(); // AffixRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        AffixRequest affixRequest = ; // AffixRequest | 

        try {
            ApiResultSetResponse result = apiInstance.prepend(affixRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#prepend");
            e.printStackTrace();
        }
    }
}

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

// 기존 값 앞에 추가
[apiInstance prependWith:affixRequest
              completionHandler: ^(ApiResultSetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var affixRequest = ; // {AffixRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var affixRequest = new AffixRequest(); // AffixRequest | 

            try {
                // 기존 값 앞에 추가
                ApiResultSetResponse result = apiInstance.prepend(affixRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.prepend: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$affixRequest = ; // AffixRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $affixRequest = WWW::OPenAPIClient::Object::AffixRequest->new(); # AffixRequest | 

eval {
    my $result = $api_instance->prepend(affixRequest => $affixRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->prepend: $@\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.KVApi()
affixRequest =  # AffixRequest | 

try:
    # 기존 값 앞에 추가
    api_response = api_instance.prepend(affixRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->prepend: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let affixRequest = ; // AffixRequest

    let mut context = KVApi::Context::default();
    let result = client.prepend(affixRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        SetRequest setRequest = ; // SetRequest | 

        try {
            ApiResultSetResponse result = apiInstance.replace(setRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#replace");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetRequest setRequest = new SetRequest(); // SetRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        SetRequest setRequest = ; // SetRequest | 

        try {
            ApiResultSetResponse result = apiInstance.replace(setRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#replace");
            e.printStackTrace();
        }
    }
}

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

// 기존 값 교체
[apiInstance replaceWith:setRequest
              completionHandler: ^(ApiResultSetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var setRequest = ; // {SetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var setRequest = new SetRequest(); // SetRequest | 

            try {
                // 기존 값 교체
                ApiResultSetResponse result = apiInstance.replace(setRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.replace: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$setRequest = ; // SetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $setRequest = WWW::OPenAPIClient::Object::SetRequest->new(); # SetRequest | 

eval {
    my $result = $api_instance->replace(setRequest => $setRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->replace: $@\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.KVApi()
setRequest =  # SetRequest | 

try:
    # 기존 값 교체
    api_response = api_instance.replace(setRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->replace: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let setRequest = ; // SetRequest

    let mut context = KVApi::Context::default();
    let result = client.replace(setRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        SetRequest setRequest = ; // SetRequest | 

        try {
            ApiResultSetResponse result = apiInstance.set(setRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#set");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetRequest setRequest = new SetRequest(); // SetRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        SetRequest setRequest = ; // SetRequest | 

        try {
            ApiResultSetResponse result = apiInstance.set(setRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#set");
            e.printStackTrace();
        }
    }
}

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

// Key-Value 저장
[apiInstance setWith:setRequest
              completionHandler: ^(ApiResultSetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var setRequest = ; // {SetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var setRequest = new SetRequest(); // SetRequest | 

            try {
                // Key-Value 저장
                ApiResultSetResponse result = apiInstance.set(setRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.set: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$setRequest = ; // SetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $setRequest = WWW::OPenAPIClient::Object::SetRequest->new(); # SetRequest | 

eval {
    my $result = $api_instance->set(setRequest => $setRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->set: $@\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.KVApi()
setRequest =  # SetRequest | 

try:
    # Key-Value 저장
    api_response = api_instance.set(setRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->set: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let setRequest = ; // SetRequest

    let mut context = KVApi::Context::default();
    let result = client.set(setRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        StoreBulkRequest storeBulkRequest = ; // StoreBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.storeBulk(storeBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#storeBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final StoreBulkRequest storeBulkRequest = new StoreBulkRequest(); // StoreBulkRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        StoreBulkRequest storeBulkRequest = ; // StoreBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.storeBulk(storeBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#storeBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 키 저장, 키별 실패 반환
[apiInstance storeBulkWith:storeBulkRequest
              completionHandler: ^(ApiResultBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var storeBulkRequest = ; // {StoreBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var storeBulkRequest = new StoreBulkRequest(); // StoreBulkRequest | 

            try {
                // 여러 키 저장, 키별 실패 반환
                ApiResultBulkResponse result = apiInstance.storeBulk(storeBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.storeBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$storeBulkRequest = ; // StoreBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $storeBulkRequest = WWW::OPenAPIClient::Object::StoreBulkRequest->new(); # StoreBulkRequest | 

eval {
    my $result = $api_instance->storeBulk(storeBulkRequest => $storeBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->storeBulk: $@\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.KVApi()
storeBulkRequest =  # StoreBulkRequest | 

try:
    # 여러 키 저장, 키별 실패 반환
    api_response = api_instance.store_bulk(storeBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->storeBulk: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let storeBulkRequest = ; // StoreBulkRequest

    let mut context = KVApi::Context::default();
    let result = client.storeBulk(storeBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        KVApi apiInstance = new KVApi();
        TouchRequest touchRequest = ; // TouchRequest | 

        try {
            ApiResultBooleanResponse result = apiInstance.touch(touchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#touch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TouchRequest touchRequest = new TouchRequest(); // TouchRequest | 

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

import org.openapitools.client.api.KVApi;

public class KVApiExample {
    public static void main(String[] args) {
        KVApi apiInstance = new KVApi();
        TouchRequest touchRequest = ; // TouchRequest | 

        try {
            ApiResultBooleanResponse result = apiInstance.touch(touchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KVApi#touch");
            e.printStackTrace();
        }
    }
}

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

// 만료시간 갱신
[apiInstance touchWith:touchRequest
              completionHandler: ^(ApiResultBooleanResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.KVApi()
var touchRequest = ; // {TouchRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new KVApi();
            var touchRequest = new TouchRequest(); // TouchRequest | 

            try {
                // 만료시간 갱신
                ApiResultBooleanResponse result = apiInstance.touch(touchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KVApi.touch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KVApi();
$touchRequest = ; // TouchRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KVApi->new();
my $touchRequest = WWW::OPenAPIClient::Object::TouchRequest->new(); # TouchRequest | 

eval {
    my $result = $api_instance->touch(touchRequest => $touchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KVApi->touch: $@\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.KVApi()
touchRequest =  # TouchRequest | 

try:
    # 만료시간 갱신
    api_response = api_instance.touch(touchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KVApi->touch: %s\n" % e)

extern crate KVApi;

pub fn main() {
    let touchRequest = ; // TouchRequest

    let mut context = KVApi::Context::default();
    let result = client.touch(touchRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ListApi apiInstance = new ListApi();
        ListCreateRequest listCreateRequest = ; // ListCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(listCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#create");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ListCreateRequest listCreateRequest = new ListCreateRequest(); // ListCreateRequest | 

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

import org.openapitools.client.api.ListApi;

public class ListApiExample {
    public static void main(String[] args) {
        ListApi apiInstance = new ListApi();
        ListCreateRequest listCreateRequest = ; // ListCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(listCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#create");
            e.printStackTrace();
        }
    }
}

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

// List 생성
[apiInstance createWith:listCreateRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ListApi()
var listCreateRequest = ; // {ListCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ListApi();
            var listCreateRequest = new ListCreateRequest(); // ListCreateRequest | 

            try {
                // List 생성
                ApiResultCollectionResponseBoolean result = apiInstance.create(listCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ListApi.create: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ListApi();
$listCreateRequest = ; // ListCreateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ListApi->new();
my $listCreateRequest = WWW::OPenAPIClient::Object::ListCreateRequest->new(); # ListCreateRequest | 

eval {
    my $result = $api_instance->create(listCreateRequest => $listCreateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ListApi->create: $@\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.ListApi()
listCreateRequest =  # ListCreateRequest | 

try:
    # List 생성
    api_response = api_instance.create(listCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ListApi->create: %s\n" % e)

extern crate ListApi;

pub fn main() {
    let listCreateRequest = ; // ListCreateRequest

    let mut context = ListApi::Context::default();
    let result = client.create(listCreateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ListApi apiInstance = new ListApi();
        ListRangeRequest listRangeRequest = ; // ListRangeRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(listRangeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#delete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ListRangeRequest listRangeRequest = new ListRangeRequest(); // ListRangeRequest | 

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

import org.openapitools.client.api.ListApi;

public class ListApiExample {
    public static void main(String[] args) {
        ListApi apiInstance = new ListApi();
        ListRangeRequest listRangeRequest = ; // ListRangeRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(listRangeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#delete");
            e.printStackTrace();
        }
    }
}

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

// 요소 삭제
[apiInstance deleteWith:listRangeRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ListApi()
var listRangeRequest = ; // {ListRangeRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ListApi();
            var listRangeRequest = new ListRangeRequest(); // ListRangeRequest | 

            try {
                // 요소 삭제
                ApiResultCollectionResponseBoolean result = apiInstance.delete(listRangeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ListApi.delete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ListApi();
$listRangeRequest = ; // ListRangeRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ListApi->new();
my $listRangeRequest = WWW::OPenAPIClient::Object::ListRangeRequest->new(); # ListRangeRequest | 

eval {
    my $result = $api_instance->delete(listRangeRequest => $listRangeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ListApi->delete: $@\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.ListApi()
listRangeRequest =  # ListRangeRequest | 

try:
    # 요소 삭제
    api_response = api_instance.delete(listRangeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ListApi->delete: %s\n" % e)

extern crate ListApi;

pub fn main() {
    let listRangeRequest = ; // ListRangeRequest

    let mut context = ListApi::Context::default();
    let result = client.delete(listRangeRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ListApi apiInstance = new ListApi();
        ListRangeRequest listRangeRequest = ; // ListRangeRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.get(listRangeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#get");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ListRangeRequest listRangeRequest = new ListRangeRequest(); // ListRangeRequest | 

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

import org.openapitools.client.api.ListApi;

public class ListApiExample {
    public static void main(String[] args) {
        ListApi apiInstance = new ListApi();
        ListRangeRequest listRangeRequest = ; // ListRangeRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.get(listRangeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#get");
            e.printStackTrace();
        }
    }
}

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

// 요소 조회
[apiInstance getWith:listRangeRequest
              completionHandler: ^(ApiResultCollectionResponseListObject output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ListApi()
var listRangeRequest = ; // {ListRangeRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ListApi();
            var listRangeRequest = new ListRangeRequest(); // ListRangeRequest | 

            try {
                // 요소 조회
                ApiResultCollectionResponseListObject result = apiInstance.get(listRangeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ListApi.get: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ListApi();
$listRangeRequest = ; // ListRangeRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ListApi->new();
my $listRangeRequest = WWW::OPenAPIClient::Object::ListRangeRequest->new(); # ListRangeRequest | 

eval {
    my $result = $api_instance->get(listRangeRequest => $listRangeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ListApi->get: $@\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.ListApi()
listRangeRequest =  # ListRangeRequest | 

try:
    # 요소 조회
    api_response = api_instance.get(listRangeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ListApi->get: %s\n" % e)

extern crate ListApi;

pub fn main() {
    let listRangeRequest = ; // ListRangeRequest

    let mut context = ListApi::Context::default();
    let result = client.get(listRangeRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ListApi apiInstance = new ListApi();
        ListRangeRequest listRangeRequest = ; // ListRangeRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.getAndDelete(listRangeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ListRangeRequest listRangeRequest = new ListRangeRequest(); // ListRangeRequest | 

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

import org.openapitools.client.api.ListApi;

public class ListApiExample {
    public static void main(String[] args) {
        ListApi apiInstance = new ListApi();
        ListRangeRequest listRangeRequest = ; // ListRangeRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.getAndDelete(listRangeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

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

// 요소 조회 후 삭제
[apiInstance getAndDeleteWith:listRangeRequest
              completionHandler: ^(ApiResultCollectionResponseListObject output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ListApi()
var listRangeRequest = ; // {ListRangeRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ListApi();
            var listRangeRequest = new ListRangeRequest(); // ListRangeRequest | 

            try {
                // 요소 조회 후 삭제
                ApiResultCollectionResponseListObject result = apiInstance.getAndDelete(listRangeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ListApi.getAndDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ListApi();
$listRangeRequest = ; // ListRangeRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ListApi->new();
my $listRangeRequest = WWW::OPenAPIClient::Object::ListRangeRequest->new(); # ListRangeRequest | 

eval {
    my $result = $api_instance->getAndDelete(listRangeRequest => $listRangeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ListApi->getAndDelete: $@\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.ListApi()
listRangeRequest =  # ListRangeRequest | 

try:
    # 요소 조회 후 삭제
    api_response = api_instance.get_and_delete(listRangeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ListApi->getAndDelete: %s\n" % e)

extern crate ListApi;

pub fn main() {
    let listRangeRequest = ; // ListRangeRequest

    let mut context = ListApi::Context::default();
    let result = client.getAndDelete(listRangeRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ListApi apiInstance = new ListApi();
        ListInsertRequest listInsertRequest = ; // ListInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(listInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#insert");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ListInsertRequest listInsertRequest = new ListInsertRequest(); // ListInsertRequest | 

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

import org.openapitools.client.api.ListApi;

public class ListApiExample {
    public static void main(String[] args) {
        ListApi apiInstance = new ListApi();
        ListInsertRequest listInsertRequest = ; // ListInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(listInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#insert");
            e.printStackTrace();
        }
    }
}

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

// List 요소 삽입
[apiInstance insertWith:listInsertRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ListApi()
var listInsertRequest = ; // {ListInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ListApi();
            var listInsertRequest = new ListInsertRequest(); // ListInsertRequest | 

            try {
                // List 요소 삽입
                ApiResultCollectionResponseBoolean result = apiInstance.insert(listInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ListApi.insert: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ListApi();
$listInsertRequest = ; // ListInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ListApi->new();
my $listInsertRequest = WWW::OPenAPIClient::Object::ListInsertRequest->new(); # ListInsertRequest | 

eval {
    my $result = $api_instance->insert(listInsertRequest => $listInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ListApi->insert: $@\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.ListApi()
listInsertRequest =  # ListInsertRequest | 

try:
    # List 요소 삽입
    api_response = api_instance.insert(listInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ListApi->insert: %s\n" % e)

extern crate ListApi;

pub fn main() {
    let listInsertRequest = ; // ListInsertRequest

    let mut context = ListApi::Context::default();
    let result = client.insert(listInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ListApi apiInstance = new ListApi();
        ListInsertBulkRequest listInsertBulkRequest = ; // ListInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(listInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#insertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ListInsertBulkRequest listInsertBulkRequest = new ListInsertBulkRequest(); // ListInsertBulkRequest | 

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

import org.openapitools.client.api.ListApi;

public class ListApiExample {
    public static void main(String[] args) {
        ListApi apiInstance = new ListApi();
        ListInsertBulkRequest listInsertBulkRequest = ; // ListInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(listInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#insertBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 컬렉션에 요소 삽입
[apiInstance insertBulkWith:listInsertBulkRequest
              completionHandler: ^(ApiResultBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ListApi()
var listInsertBulkRequest = ; // {ListInsertBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ListApi();
            var listInsertBulkRequest = new ListInsertBulkRequest(); // ListInsertBulkRequest | 

            try {
                // 여러 컬렉션에 요소 삽입
                ApiResultBulkResponse result = apiInstance.insertBulk(listInsertBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ListApi.insertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ListApi();
$listInsertBulkRequest = ; // ListInsertBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ListApi->new();
my $listInsertBulkRequest = WWW::OPenAPIClient::Object::ListInsertBulkRequest->new(); # ListInsertBulkRequest | 

eval {
    my $result = $api_instance->insertBulk(listInsertBulkRequest => $listInsertBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ListApi->insertBulk: $@\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.ListApi()
listInsertBulkRequest =  # ListInsertBulkRequest | 

try:
    # 여러 컬렉션에 요소 삽입
    api_response = api_instance.insert_bulk(listInsertBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ListApi->insertBulk: %s\n" % e)

extern crate ListApi;

pub fn main() {
    let listInsertBulkRequest = ; // ListInsertBulkRequest

    let mut context = ListApi::Context::default();
    let result = client.insertBulk(listInsertBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ListApi apiInstance = new ListApi();
        ListPipedInsertRequest listPipedInsertRequest = ; // ListPipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(listPipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ListPipedInsertRequest listPipedInsertRequest = new ListPipedInsertRequest(); // ListPipedInsertRequest | 

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

import org.openapitools.client.api.ListApi;

public class ListApiExample {
    public static void main(String[] args) {
        ListApi apiInstance = new ListApi();
        ListPipedInsertRequest listPipedInsertRequest = ; // ListPipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(listPipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ListApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

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

// piped-insert-bulk
[apiInstance pipedInsertBulkWith:listPipedInsertRequest
              completionHandler: ^(ApiResultIndexedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ListApi()
var listPipedInsertRequest = ; // {ListPipedInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ListApi();
            var listPipedInsertRequest = new ListPipedInsertRequest(); // ListPipedInsertRequest | 

            try {
                // piped-insert-bulk
                ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(listPipedInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ListApi.pipedInsertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ListApi();
$listPipedInsertRequest = ; // ListPipedInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ListApi->new();
my $listPipedInsertRequest = WWW::OPenAPIClient::Object::ListPipedInsertRequest->new(); # ListPipedInsertRequest | 

eval {
    my $result = $api_instance->pipedInsertBulk(listPipedInsertRequest => $listPipedInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ListApi->pipedInsertBulk: $@\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.ListApi()
listPipedInsertRequest =  # ListPipedInsertRequest | 

try:
    # piped-insert-bulk
    api_response = api_instance.piped_insert_bulk(listPipedInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ListApi->pipedInsertBulk: %s\n" % e)

extern crate ListApi;

pub fn main() {
    let listPipedInsertRequest = ; // ListPipedInsertRequest

    let mut context = ListApi::Context::default();
    let result = client.pipedInsertBulk(listPipedInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetCreateRequest setCreateRequest = ; // SetCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(setCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#create");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetCreateRequest setCreateRequest = new SetCreateRequest(); // SetCreateRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetCreateRequest setCreateRequest = ; // SetCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(setCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#create");
            e.printStackTrace();
        }
    }
}

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

// Set 생성
[apiInstance createWith:setCreateRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setCreateRequest = ; // {SetCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setCreateRequest = new SetCreateRequest(); // SetCreateRequest | 

            try {
                // Set 생성
                ApiResultCollectionResponseBoolean result = apiInstance.create(setCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.create: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setCreateRequest = ; // SetCreateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setCreateRequest = WWW::OPenAPIClient::Object::SetCreateRequest->new(); # SetCreateRequest | 

eval {
    my $result = $api_instance->create(setCreateRequest => $setCreateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->create: $@\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.SetApi()
setCreateRequest =  # SetCreateRequest | 

try:
    # Set 생성
    api_response = api_instance.create(setCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->create: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setCreateRequest = ; // SetCreateRequest

    let mut context = SetApi::Context::default();
    let result = client.create(setCreateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetValueRequest setValueRequest = ; // SetValueRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(setValueRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#delete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetValueRequest setValueRequest = new SetValueRequest(); // SetValueRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetValueRequest setValueRequest = ; // SetValueRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(setValueRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#delete");
            e.printStackTrace();
        }
    }
}

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

// 요소 삭제
[apiInstance deleteWith:setValueRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setValueRequest = ; // {SetValueRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setValueRequest = new SetValueRequest(); // SetValueRequest | 

            try {
                // 요소 삭제
                ApiResultCollectionResponseBoolean result = apiInstance.delete(setValueRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.delete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setValueRequest = ; // SetValueRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setValueRequest = WWW::OPenAPIClient::Object::SetValueRequest->new(); # SetValueRequest | 

eval {
    my $result = $api_instance->delete(setValueRequest => $setValueRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->delete: $@\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.SetApi()
setValueRequest =  # SetValueRequest | 

try:
    # 요소 삭제
    api_response = api_instance.delete(setValueRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->delete: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setValueRequest = ; // SetValueRequest

    let mut context = SetApi::Context::default();
    let result = client.delete(setValueRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetValueRequest setValueRequest = ; // SetValueRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.exist(setValueRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#exist");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetValueRequest setValueRequest = new SetValueRequest(); // SetValueRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetValueRequest setValueRequest = ; // SetValueRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.exist(setValueRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#exist");
            e.printStackTrace();
        }
    }
}

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

// 요소 존재 확인
[apiInstance existWith:setValueRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setValueRequest = ; // {SetValueRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setValueRequest = new SetValueRequest(); // SetValueRequest | 

            try {
                // 요소 존재 확인
                ApiResultCollectionResponseBoolean result = apiInstance.exist(setValueRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.exist: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setValueRequest = ; // SetValueRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setValueRequest = WWW::OPenAPIClient::Object::SetValueRequest->new(); # SetValueRequest | 

eval {
    my $result = $api_instance->exist(setValueRequest => $setValueRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->exist: $@\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.SetApi()
setValueRequest =  # SetValueRequest | 

try:
    # 요소 존재 확인
    api_response = api_instance.exist(setValueRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->exist: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setValueRequest = ; // SetValueRequest

    let mut context = SetApi::Context::default();
    let result = client.exist(setValueRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetGetRequest setGetRequest = ; // SetGetRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.get(setGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#get");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetGetRequest setGetRequest = new SetGetRequest(); // SetGetRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetGetRequest setGetRequest = ; // SetGetRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.get(setGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#get");
            e.printStackTrace();
        }
    }
}

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

// 요소 조회
[apiInstance getWith:setGetRequest
              completionHandler: ^(ApiResultCollectionResponseListObject output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setGetRequest = ; // {SetGetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setGetRequest = new SetGetRequest(); // SetGetRequest | 

            try {
                // 요소 조회
                ApiResultCollectionResponseListObject result = apiInstance.get(setGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.get: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setGetRequest = ; // SetGetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setGetRequest = WWW::OPenAPIClient::Object::SetGetRequest->new(); # SetGetRequest | 

eval {
    my $result = $api_instance->get(setGetRequest => $setGetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->get: $@\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.SetApi()
setGetRequest =  # SetGetRequest | 

try:
    # 요소 조회
    api_response = api_instance.get(setGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->get: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setGetRequest = ; // SetGetRequest

    let mut context = SetApi::Context::default();
    let result = client.get(setGetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetGetRequest setGetRequest = ; // SetGetRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.getAndDelete(setGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetGetRequest setGetRequest = new SetGetRequest(); // SetGetRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetGetRequest setGetRequest = ; // SetGetRequest | 

        try {
            ApiResultCollectionResponseListObject result = apiInstance.getAndDelete(setGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

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

// 요소 조회 후 삭제
[apiInstance getAndDeleteWith:setGetRequest
              completionHandler: ^(ApiResultCollectionResponseListObject output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setGetRequest = ; // {SetGetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setGetRequest = new SetGetRequest(); // SetGetRequest | 

            try {
                // 요소 조회 후 삭제
                ApiResultCollectionResponseListObject result = apiInstance.getAndDelete(setGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.getAndDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setGetRequest = ; // SetGetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setGetRequest = WWW::OPenAPIClient::Object::SetGetRequest->new(); # SetGetRequest | 

eval {
    my $result = $api_instance->getAndDelete(setGetRequest => $setGetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->getAndDelete: $@\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.SetApi()
setGetRequest =  # SetGetRequest | 

try:
    # 요소 조회 후 삭제
    api_response = api_instance.get_and_delete(setGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->getAndDelete: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setGetRequest = ; // SetGetRequest

    let mut context = SetApi::Context::default();
    let result = client.getAndDelete(setGetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetInsertRequest setInsertRequest = ; // SetInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(setInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#insert");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetInsertRequest setInsertRequest = new SetInsertRequest(); // SetInsertRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetInsertRequest setInsertRequest = ; // SetInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(setInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#insert");
            e.printStackTrace();
        }
    }
}

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

// Set 요소 삽입
[apiInstance insertWith:setInsertRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setInsertRequest = ; // {SetInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setInsertRequest = new SetInsertRequest(); // SetInsertRequest | 

            try {
                // Set 요소 삽입
                ApiResultCollectionResponseBoolean result = apiInstance.insert(setInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.insert: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setInsertRequest = ; // SetInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setInsertRequest = WWW::OPenAPIClient::Object::SetInsertRequest->new(); # SetInsertRequest | 

eval {
    my $result = $api_instance->insert(setInsertRequest => $setInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->insert: $@\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.SetApi()
setInsertRequest =  # SetInsertRequest | 

try:
    # Set 요소 삽입
    api_response = api_instance.insert(setInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->insert: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setInsertRequest = ; // SetInsertRequest

    let mut context = SetApi::Context::default();
    let result = client.insert(setInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetInsertBulkRequest setInsertBulkRequest = ; // SetInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(setInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#insertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetInsertBulkRequest setInsertBulkRequest = new SetInsertBulkRequest(); // SetInsertBulkRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetInsertBulkRequest setInsertBulkRequest = ; // SetInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(setInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#insertBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 컬렉션에 요소 삽입
[apiInstance insertBulkWith:setInsertBulkRequest
              completionHandler: ^(ApiResultBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setInsertBulkRequest = ; // {SetInsertBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setInsertBulkRequest = new SetInsertBulkRequest(); // SetInsertBulkRequest | 

            try {
                // 여러 컬렉션에 요소 삽입
                ApiResultBulkResponse result = apiInstance.insertBulk(setInsertBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.insertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setInsertBulkRequest = ; // SetInsertBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setInsertBulkRequest = WWW::OPenAPIClient::Object::SetInsertBulkRequest->new(); # SetInsertBulkRequest | 

eval {
    my $result = $api_instance->insertBulk(setInsertBulkRequest => $setInsertBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->insertBulk: $@\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.SetApi()
setInsertBulkRequest =  # SetInsertBulkRequest | 

try:
    # 여러 컬렉션에 요소 삽입
    api_response = api_instance.insert_bulk(setInsertBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->insertBulk: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setInsertBulkRequest = ; // SetInsertBulkRequest

    let mut context = SetApi::Context::default();
    let result = client.insertBulk(setInsertBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetPipedExistRequest setPipedExistRequest = ; // SetPipedExistRequest | 

        try {
            ApiResultCollectionResponseListSetExistenceResponse result = apiInstance.pipedExistBulk(setPipedExistRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#pipedExistBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetPipedExistRequest setPipedExistRequest = new SetPipedExistRequest(); // SetPipedExistRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetPipedExistRequest setPipedExistRequest = ; // SetPipedExistRequest | 

        try {
            ApiResultCollectionResponseListSetExistenceResponse result = apiInstance.pipedExistBulk(setPipedExistRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#pipedExistBulk");
            e.printStackTrace();
        }
    }
}

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

// piped-exist-bulk
[apiInstance pipedExistBulkWith:setPipedExistRequest
              completionHandler: ^(ApiResultCollectionResponseListSetExistenceResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setPipedExistRequest = ; // {SetPipedExistRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setPipedExistRequest = new SetPipedExistRequest(); // SetPipedExistRequest | 

            try {
                // piped-exist-bulk
                ApiResultCollectionResponseListSetExistenceResponse result = apiInstance.pipedExistBulk(setPipedExistRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.pipedExistBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setPipedExistRequest = ; // SetPipedExistRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setPipedExistRequest = WWW::OPenAPIClient::Object::SetPipedExistRequest->new(); # SetPipedExistRequest | 

eval {
    my $result = $api_instance->pipedExistBulk(setPipedExistRequest => $setPipedExistRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->pipedExistBulk: $@\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.SetApi()
setPipedExistRequest =  # SetPipedExistRequest | 

try:
    # piped-exist-bulk
    api_response = api_instance.piped_exist_bulk(setPipedExistRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->pipedExistBulk: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setPipedExistRequest = ; // SetPipedExistRequest

    let mut context = SetApi::Context::default();
    let result = client.pipedExistBulk(setPipedExistRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SetApi apiInstance = new SetApi();
        SetPipedInsertRequest setPipedInsertRequest = ; // SetPipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(setPipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetPipedInsertRequest setPipedInsertRequest = new SetPipedInsertRequest(); // SetPipedInsertRequest | 

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

import org.openapitools.client.api.SetApi;

public class SetApiExample {
    public static void main(String[] args) {
        SetApi apiInstance = new SetApi();
        SetPipedInsertRequest setPipedInsertRequest = ; // SetPipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(setPipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SetApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

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

// piped-insert-bulk
[apiInstance pipedInsertBulkWith:setPipedInsertRequest
              completionHandler: ^(ApiResultIndexedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.SetApi()
var setPipedInsertRequest = ; // {SetPipedInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SetApi();
            var setPipedInsertRequest = new SetPipedInsertRequest(); // SetPipedInsertRequest | 

            try {
                // piped-insert-bulk
                ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(setPipedInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SetApi.pipedInsertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SetApi();
$setPipedInsertRequest = ; // SetPipedInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SetApi->new();
my $setPipedInsertRequest = WWW::OPenAPIClient::Object::SetPipedInsertRequest->new(); # SetPipedInsertRequest | 

eval {
    my $result = $api_instance->pipedInsertBulk(setPipedInsertRequest => $setPipedInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SetApi->pipedInsertBulk: $@\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.SetApi()
setPipedInsertRequest =  # SetPipedInsertRequest | 

try:
    # piped-insert-bulk
    api_response = api_instance.piped_insert_bulk(setPipedInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SetApi->pipedInsertBulk: %s\n" % e)

extern crate SetApi;

pub fn main() {
    let setPipedInsertRequest = ; // SetPipedInsertRequest

    let mut context = SetApi::Context::default();
    let result = client.pipedInsertBulk(setPipedInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapCreateRequest mapCreateRequest = ; // MapCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(mapCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#create");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapCreateRequest mapCreateRequest = new MapCreateRequest(); // MapCreateRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapCreateRequest mapCreateRequest = ; // MapCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(mapCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#create");
            e.printStackTrace();
        }
    }
}

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

// Map 생성
[apiInstance createWith:mapCreateRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapCreateRequest = ; // {MapCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapCreateRequest = new MapCreateRequest(); // MapCreateRequest | 

            try {
                // Map 생성
                ApiResultCollectionResponseBoolean result = apiInstance.create(mapCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.create: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapCreateRequest = ; // MapCreateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapCreateRequest = WWW::OPenAPIClient::Object::MapCreateRequest->new(); # MapCreateRequest | 

eval {
    my $result = $api_instance->create(mapCreateRequest => $mapCreateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->create: $@\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.MapApi()
mapCreateRequest =  # MapCreateRequest | 

try:
    # Map 생성
    api_response = api_instance.create(mapCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->create: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapCreateRequest = ; // MapCreateRequest

    let mut context = MapApi::Context::default();
    let result = client.create(mapCreateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapDeleteRequest mapDeleteRequest = ; // MapDeleteRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(mapDeleteRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#delete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapDeleteRequest mapDeleteRequest = new MapDeleteRequest(); // MapDeleteRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapDeleteRequest mapDeleteRequest = ; // MapDeleteRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(mapDeleteRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#delete");
            e.printStackTrace();
        }
    }
}

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

// 요소 삭제
[apiInstance deleteWith:mapDeleteRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapDeleteRequest = ; // {MapDeleteRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapDeleteRequest = new MapDeleteRequest(); // MapDeleteRequest | 

            try {
                // 요소 삭제
                ApiResultCollectionResponseBoolean result = apiInstance.delete(mapDeleteRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.delete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapDeleteRequest = ; // MapDeleteRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapDeleteRequest = WWW::OPenAPIClient::Object::MapDeleteRequest->new(); # MapDeleteRequest | 

eval {
    my $result = $api_instance->delete(mapDeleteRequest => $mapDeleteRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->delete: $@\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.MapApi()
mapDeleteRequest =  # MapDeleteRequest | 

try:
    # 요소 삭제
    api_response = api_instance.delete(mapDeleteRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->delete: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapDeleteRequest = ; // MapDeleteRequest

    let mut context = MapApi::Context::default();
    let result = client.delete(mapDeleteRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapGetRequest mapGetRequest = ; // MapGetRequest | 

        try {
            ApiResultCollectionResponseMapStringObject result = apiInstance.get(mapGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#get");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapGetRequest mapGetRequest = new MapGetRequest(); // MapGetRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapGetRequest mapGetRequest = ; // MapGetRequest | 

        try {
            ApiResultCollectionResponseMapStringObject result = apiInstance.get(mapGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#get");
            e.printStackTrace();
        }
    }
}

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

// 요소 조회
[apiInstance getWith:mapGetRequest
              completionHandler: ^(ApiResultCollectionResponseMapStringObject output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapGetRequest = ; // {MapGetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapGetRequest = new MapGetRequest(); // MapGetRequest | 

            try {
                // 요소 조회
                ApiResultCollectionResponseMapStringObject result = apiInstance.get(mapGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.get: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapGetRequest = ; // MapGetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapGetRequest = WWW::OPenAPIClient::Object::MapGetRequest->new(); # MapGetRequest | 

eval {
    my $result = $api_instance->get(mapGetRequest => $mapGetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->get: $@\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.MapApi()
mapGetRequest =  # MapGetRequest | 

try:
    # 요소 조회
    api_response = api_instance.get(mapGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->get: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapGetRequest = ; // MapGetRequest

    let mut context = MapApi::Context::default();
    let result = client.get(mapGetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapGetRequest mapGetRequest = ; // MapGetRequest | 

        try {
            ApiResultCollectionResponseMapStringObject result = apiInstance.getAndDelete(mapGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapGetRequest mapGetRequest = new MapGetRequest(); // MapGetRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapGetRequest mapGetRequest = ; // MapGetRequest | 

        try {
            ApiResultCollectionResponseMapStringObject result = apiInstance.getAndDelete(mapGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

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

// 요소 조회 후 삭제
[apiInstance getAndDeleteWith:mapGetRequest
              completionHandler: ^(ApiResultCollectionResponseMapStringObject output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapGetRequest = ; // {MapGetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapGetRequest = new MapGetRequest(); // MapGetRequest | 

            try {
                // 요소 조회 후 삭제
                ApiResultCollectionResponseMapStringObject result = apiInstance.getAndDelete(mapGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.getAndDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapGetRequest = ; // MapGetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapGetRequest = WWW::OPenAPIClient::Object::MapGetRequest->new(); # MapGetRequest | 

eval {
    my $result = $api_instance->getAndDelete(mapGetRequest => $mapGetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->getAndDelete: $@\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.MapApi()
mapGetRequest =  # MapGetRequest | 

try:
    # 요소 조회 후 삭제
    api_response = api_instance.get_and_delete(mapGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->getAndDelete: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapGetRequest = ; // MapGetRequest

    let mut context = MapApi::Context::default();
    let result = client.getAndDelete(mapGetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapInsertRequest mapInsertRequest = ; // MapInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(mapInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#insert");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapInsertRequest mapInsertRequest = new MapInsertRequest(); // MapInsertRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapInsertRequest mapInsertRequest = ; // MapInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(mapInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#insert");
            e.printStackTrace();
        }
    }
}

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

// Map 요소 삽입
[apiInstance insertWith:mapInsertRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapInsertRequest = ; // {MapInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapInsertRequest = new MapInsertRequest(); // MapInsertRequest | 

            try {
                // Map 요소 삽입
                ApiResultCollectionResponseBoolean result = apiInstance.insert(mapInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.insert: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapInsertRequest = ; // MapInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapInsertRequest = WWW::OPenAPIClient::Object::MapInsertRequest->new(); # MapInsertRequest | 

eval {
    my $result = $api_instance->insert(mapInsertRequest => $mapInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->insert: $@\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.MapApi()
mapInsertRequest =  # MapInsertRequest | 

try:
    # Map 요소 삽입
    api_response = api_instance.insert(mapInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->insert: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapInsertRequest = ; // MapInsertRequest

    let mut context = MapApi::Context::default();
    let result = client.insert(mapInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapInsertBulkRequest mapInsertBulkRequest = ; // MapInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(mapInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#insertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapInsertBulkRequest mapInsertBulkRequest = new MapInsertBulkRequest(); // MapInsertBulkRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapInsertBulkRequest mapInsertBulkRequest = ; // MapInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(mapInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#insertBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 컬렉션에 요소 삽입
[apiInstance insertBulkWith:mapInsertBulkRequest
              completionHandler: ^(ApiResultBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapInsertBulkRequest = ; // {MapInsertBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapInsertBulkRequest = new MapInsertBulkRequest(); // MapInsertBulkRequest | 

            try {
                // 여러 컬렉션에 요소 삽입
                ApiResultBulkResponse result = apiInstance.insertBulk(mapInsertBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.insertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapInsertBulkRequest = ; // MapInsertBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapInsertBulkRequest = WWW::OPenAPIClient::Object::MapInsertBulkRequest->new(); # MapInsertBulkRequest | 

eval {
    my $result = $api_instance->insertBulk(mapInsertBulkRequest => $mapInsertBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->insertBulk: $@\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.MapApi()
mapInsertBulkRequest =  # MapInsertBulkRequest | 

try:
    # 여러 컬렉션에 요소 삽입
    api_response = api_instance.insert_bulk(mapInsertBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->insertBulk: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapInsertBulkRequest = ; // MapInsertBulkRequest

    let mut context = MapApi::Context::default();
    let result = client.insertBulk(mapInsertBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapPipedInsertRequest mapPipedInsertRequest = ; // MapPipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(mapPipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapPipedInsertRequest mapPipedInsertRequest = new MapPipedInsertRequest(); // MapPipedInsertRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapPipedInsertRequest mapPipedInsertRequest = ; // MapPipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(mapPipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

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

// piped-insert-bulk
[apiInstance pipedInsertBulkWith:mapPipedInsertRequest
              completionHandler: ^(ApiResultIndexedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapPipedInsertRequest = ; // {MapPipedInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapPipedInsertRequest = new MapPipedInsertRequest(); // MapPipedInsertRequest | 

            try {
                // piped-insert-bulk
                ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(mapPipedInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.pipedInsertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapPipedInsertRequest = ; // MapPipedInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapPipedInsertRequest = WWW::OPenAPIClient::Object::MapPipedInsertRequest->new(); # MapPipedInsertRequest | 

eval {
    my $result = $api_instance->pipedInsertBulk(mapPipedInsertRequest => $mapPipedInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->pipedInsertBulk: $@\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.MapApi()
mapPipedInsertRequest =  # MapPipedInsertRequest | 

try:
    # piped-insert-bulk
    api_response = api_instance.piped_insert_bulk(mapPipedInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->pipedInsertBulk: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapPipedInsertRequest = ; // MapPipedInsertRequest

    let mut context = MapApi::Context::default();
    let result = client.pipedInsertBulk(mapPipedInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapPipedUpdateRequest mapPipedUpdateRequest = ; // MapPipedUpdateRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedUpdateBulk(mapPipedUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#pipedUpdateBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapPipedUpdateRequest mapPipedUpdateRequest = new MapPipedUpdateRequest(); // MapPipedUpdateRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapPipedUpdateRequest mapPipedUpdateRequest = ; // MapPipedUpdateRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedUpdateBulk(mapPipedUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#pipedUpdateBulk");
            e.printStackTrace();
        }
    }
}

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

// piped-update-bulk
[apiInstance pipedUpdateBulkWith:mapPipedUpdateRequest
              completionHandler: ^(ApiResultIndexedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapPipedUpdateRequest = ; // {MapPipedUpdateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapPipedUpdateRequest = new MapPipedUpdateRequest(); // MapPipedUpdateRequest | 

            try {
                // piped-update-bulk
                ApiResultIndexedResponse result = apiInstance.pipedUpdateBulk(mapPipedUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.pipedUpdateBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapPipedUpdateRequest = ; // MapPipedUpdateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapPipedUpdateRequest = WWW::OPenAPIClient::Object::MapPipedUpdateRequest->new(); # MapPipedUpdateRequest | 

eval {
    my $result = $api_instance->pipedUpdateBulk(mapPipedUpdateRequest => $mapPipedUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->pipedUpdateBulk: $@\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.MapApi()
mapPipedUpdateRequest =  # MapPipedUpdateRequest | 

try:
    # piped-update-bulk
    api_response = api_instance.piped_update_bulk(mapPipedUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->pipedUpdateBulk: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapPipedUpdateRequest = ; // MapPipedUpdateRequest

    let mut context = MapApi::Context::default();
    let result = client.pipedUpdateBulk(mapPipedUpdateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapUpdateRequest mapUpdateRequest = ; // MapUpdateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.update(mapUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#update");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapUpdateRequest mapUpdateRequest = new MapUpdateRequest(); // MapUpdateRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapUpdateRequest mapUpdateRequest = ; // MapUpdateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.update(mapUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#update");
            e.printStackTrace();
        }
    }
}

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

// 기존 요소 변경
[apiInstance updateWith:mapUpdateRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapUpdateRequest = ; // {MapUpdateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapUpdateRequest = new MapUpdateRequest(); // MapUpdateRequest | 

            try {
                // 기존 요소 변경
                ApiResultCollectionResponseBoolean result = apiInstance.update(mapUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.update: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapUpdateRequest = ; // MapUpdateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapUpdateRequest = WWW::OPenAPIClient::Object::MapUpdateRequest->new(); # MapUpdateRequest | 

eval {
    my $result = $api_instance->update(mapUpdateRequest => $mapUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->update: $@\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.MapApi()
mapUpdateRequest =  # MapUpdateRequest | 

try:
    # 기존 요소 변경
    api_response = api_instance.update(mapUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->update: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapUpdateRequest = ; // MapUpdateRequest

    let mut context = MapApi::Context::default();
    let result = client.update(mapUpdateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MapApi apiInstance = new MapApi();
        MapInsertRequest mapInsertRequest = ; // MapInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.upsert(mapInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#upsert");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MapInsertRequest mapInsertRequest = new MapInsertRequest(); // MapInsertRequest | 

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

import org.openapitools.client.api.MapApi;

public class MapApiExample {
    public static void main(String[] args) {
        MapApi apiInstance = new MapApi();
        MapInsertRequest mapInsertRequest = ; // MapInsertRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.upsert(mapInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MapApi#upsert");
            e.printStackTrace();
        }
    }
}

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

// 요소 삽입 또는 교체
[apiInstance upsertWith:mapInsertRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.MapApi()
var mapInsertRequest = ; // {MapInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MapApi();
            var mapInsertRequest = new MapInsertRequest(); // MapInsertRequest | 

            try {
                // 요소 삽입 또는 교체
                ApiResultCollectionResponseBoolean result = apiInstance.upsert(mapInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MapApi.upsert: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MapApi();
$mapInsertRequest = ; // MapInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MapApi->new();
my $mapInsertRequest = WWW::OPenAPIClient::Object::MapInsertRequest->new(); # MapInsertRequest | 

eval {
    my $result = $api_instance->upsert(mapInsertRequest => $mapInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MapApi->upsert: $@\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.MapApi()
mapInsertRequest =  # MapInsertRequest | 

try:
    # 요소 삽입 또는 교체
    api_response = api_instance.upsert(mapInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MapApi->upsert: %s\n" % e)

extern crate MapApi;

pub fn main() {
    let mapInsertRequest = ; // MapInsertRequest

    let mut context = MapApi::Context::default();
    let result = client.upsert(mapInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeCreateRequest bTreeCreateRequest = ; // BTreeCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(bTreeCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#create");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeCreateRequest bTreeCreateRequest = new BTreeCreateRequest(); // BTreeCreateRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeCreateRequest bTreeCreateRequest = ; // BTreeCreateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.create(bTreeCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#create");
            e.printStackTrace();
        }
    }
}

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

// 빈 B+Tree 생성
[apiInstance createWith:bTreeCreateRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeCreateRequest = ; // {BTreeCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeCreateRequest = new BTreeCreateRequest(); // BTreeCreateRequest | 

            try {
                // 빈 B+Tree 생성
                ApiResultCollectionResponseBoolean result = apiInstance.create(bTreeCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.create: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeCreateRequest = ; // BTreeCreateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeCreateRequest = WWW::OPenAPIClient::Object::BTreeCreateRequest->new(); # BTreeCreateRequest | 

eval {
    my $result = $api_instance->create(bTreeCreateRequest => $bTreeCreateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->create: $@\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.BTreeApi()
bTreeCreateRequest =  # BTreeCreateRequest | 

try:
    # 빈 B+Tree 생성
    api_response = api_instance.create(bTreeCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->create: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeCreateRequest = ; // BTreeCreateRequest

    let mut context = BTreeApi::Context::default();
    let result = client.create(bTreeCreateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeCounterRequest bTreeCounterRequest = ; // BTreeCounterRequest | 

        try {
            ApiResultCollectionResponseString result = apiInstance.decr(bTreeCounterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#decr");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeCounterRequest bTreeCounterRequest = new BTreeCounterRequest(); // BTreeCounterRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeCounterRequest bTreeCounterRequest = ; // BTreeCounterRequest | 

        try {
            ApiResultCollectionResponseString result = apiInstance.decr(bTreeCounterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#decr");
            e.printStackTrace();
        }
    }
}

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

// 요소 값 증감
[apiInstance decrWith:bTreeCounterRequest
              completionHandler: ^(ApiResultCollectionResponseString output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeCounterRequest = ; // {BTreeCounterRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeCounterRequest = new BTreeCounterRequest(); // BTreeCounterRequest | 

            try {
                // 요소 값 증감
                ApiResultCollectionResponseString result = apiInstance.decr(bTreeCounterRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.decr: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeCounterRequest = ; // BTreeCounterRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeCounterRequest = WWW::OPenAPIClient::Object::BTreeCounterRequest->new(); # BTreeCounterRequest | 

eval {
    my $result = $api_instance->decr(bTreeCounterRequest => $bTreeCounterRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->decr: $@\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.BTreeApi()
bTreeCounterRequest =  # BTreeCounterRequest | 

try:
    # 요소 값 증감
    api_response = api_instance.decr(bTreeCounterRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->decr: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeCounterRequest = ; // BTreeCounterRequest

    let mut context = BTreeApi::Context::default();
    let result = client.decr(bTreeCounterRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeDeleteRequest bTreeDeleteRequest = ; // BTreeDeleteRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(bTreeDeleteRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#delete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeDeleteRequest bTreeDeleteRequest = new BTreeDeleteRequest(); // BTreeDeleteRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeDeleteRequest bTreeDeleteRequest = ; // BTreeDeleteRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.delete(bTreeDeleteRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#delete");
            e.printStackTrace();
        }
    }
}

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

// 요소 삭제
[apiInstance deleteWith:bTreeDeleteRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeDeleteRequest = ; // {BTreeDeleteRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeDeleteRequest = new BTreeDeleteRequest(); // BTreeDeleteRequest | 

            try {
                // 요소 삭제
                ApiResultCollectionResponseBoolean result = apiInstance.delete(bTreeDeleteRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.delete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeDeleteRequest = ; // BTreeDeleteRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeDeleteRequest = WWW::OPenAPIClient::Object::BTreeDeleteRequest->new(); # BTreeDeleteRequest | 

eval {
    my $result = $api_instance->delete(bTreeDeleteRequest => $bTreeDeleteRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->delete: $@\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.BTreeApi()
bTreeDeleteRequest =  # BTreeDeleteRequest | 

try:
    # 요소 삭제
    api_response = api_instance.delete(bTreeDeleteRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->delete: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeDeleteRequest = ; // BTreeDeleteRequest

    let mut context = BTreeApi::Context::default();
    let result = client.delete(bTreeDeleteRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreePositionRequest bTreePositionRequest = ; // BTreePositionRequest | 

        try {
            ApiResultCollectionResponseInteger result = apiInstance.findPosition(bTreePositionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#findPosition");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreePositionRequest bTreePositionRequest = new BTreePositionRequest(); // BTreePositionRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreePositionRequest bTreePositionRequest = ; // BTreePositionRequest | 

        try {
            ApiResultCollectionResponseInteger result = apiInstance.findPosition(bTreePositionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#findPosition");
            e.printStackTrace();
        }
    }
}

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

// bKey 순위 조회
[apiInstance findPositionWith:bTreePositionRequest
              completionHandler: ^(ApiResultCollectionResponseInteger output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreePositionRequest = ; // {BTreePositionRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreePositionRequest = new BTreePositionRequest(); // BTreePositionRequest | 

            try {
                // bKey 순위 조회
                ApiResultCollectionResponseInteger result = apiInstance.findPosition(bTreePositionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.findPosition: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreePositionRequest = ; // BTreePositionRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreePositionRequest = WWW::OPenAPIClient::Object::BTreePositionRequest->new(); # BTreePositionRequest | 

eval {
    my $result = $api_instance->findPosition(bTreePositionRequest => $bTreePositionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->findPosition: $@\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.BTreeApi()
bTreePositionRequest =  # BTreePositionRequest | 

try:
    # bKey 순위 조회
    api_response = api_instance.find_position(bTreePositionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->findPosition: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreePositionRequest = ; // BTreePositionRequest

    let mut context = BTreeApi::Context::default();
    let result = client.findPosition(bTreePositionRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeAroundRequest bTreeAroundRequest = ; // BTreeAroundRequest | 

        try {
            ApiResultCollectionResponseMapIntegerBTreeElementResponse result = apiInstance.findPositionWithGet(bTreeAroundRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#findPositionWithGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeAroundRequest bTreeAroundRequest = new BTreeAroundRequest(); // BTreeAroundRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeAroundRequest bTreeAroundRequest = ; // BTreeAroundRequest | 

        try {
            ApiResultCollectionResponseMapIntegerBTreeElementResponse result = apiInstance.findPositionWithGet(bTreeAroundRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#findPositionWithGet");
            e.printStackTrace();
        }
    }
}

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

// 순위와 주변 요소 조회
[apiInstance findPositionWithGetWith:bTreeAroundRequest
              completionHandler: ^(ApiResultCollectionResponseMapIntegerBTreeElementResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeAroundRequest = ; // {BTreeAroundRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeAroundRequest = new BTreeAroundRequest(); // BTreeAroundRequest | 

            try {
                // 순위와 주변 요소 조회
                ApiResultCollectionResponseMapIntegerBTreeElementResponse result = apiInstance.findPositionWithGet(bTreeAroundRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.findPositionWithGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeAroundRequest = ; // BTreeAroundRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeAroundRequest = WWW::OPenAPIClient::Object::BTreeAroundRequest->new(); # BTreeAroundRequest | 

eval {
    my $result = $api_instance->findPositionWithGet(bTreeAroundRequest => $bTreeAroundRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->findPositionWithGet: $@\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.BTreeApi()
bTreeAroundRequest =  # BTreeAroundRequest | 

try:
    # 순위와 주변 요소 조회
    api_response = api_instance.find_position_with_get(bTreeAroundRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->findPositionWithGet: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeAroundRequest = ; // BTreeAroundRequest

    let mut context = BTreeApi::Context::default();
    let result = client.findPositionWithGet(bTreeAroundRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeGetRequest bTreeGetRequest = ; // BTreeGetRequest | 

        try {
            ApiResultCollectionResponseListBTreeElementResponse result = apiInstance.get(bTreeGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#get");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeGetRequest bTreeGetRequest = new BTreeGetRequest(); // BTreeGetRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeGetRequest bTreeGetRequest = ; // BTreeGetRequest | 

        try {
            ApiResultCollectionResponseListBTreeElementResponse result = apiInstance.get(bTreeGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#get");
            e.printStackTrace();
        }
    }
}

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

// bKey 범위 조회
[apiInstance getWith:bTreeGetRequest
              completionHandler: ^(ApiResultCollectionResponseListBTreeElementResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeGetRequest = ; // {BTreeGetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeGetRequest = new BTreeGetRequest(); // BTreeGetRequest | 

            try {
                // bKey 범위 조회
                ApiResultCollectionResponseListBTreeElementResponse result = apiInstance.get(bTreeGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.get: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeGetRequest = ; // BTreeGetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeGetRequest = WWW::OPenAPIClient::Object::BTreeGetRequest->new(); # BTreeGetRequest | 

eval {
    my $result = $api_instance->get(bTreeGetRequest => $bTreeGetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->get: $@\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.BTreeApi()
bTreeGetRequest =  # BTreeGetRequest | 

try:
    # bKey 범위 조회
    api_response = api_instance.get(bTreeGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->get: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeGetRequest = ; // BTreeGetRequest

    let mut context = BTreeApi::Context::default();
    let result = client.get(bTreeGetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeGetRequest bTreeGetRequest = ; // BTreeGetRequest | 

        try {
            ApiResultCollectionResponseListBTreeElementResponse result = apiInstance.getAndDelete(bTreeGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeGetRequest bTreeGetRequest = new BTreeGetRequest(); // BTreeGetRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeGetRequest bTreeGetRequest = ; // BTreeGetRequest | 

        try {
            ApiResultCollectionResponseListBTreeElementResponse result = apiInstance.getAndDelete(bTreeGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getAndDelete");
            e.printStackTrace();
        }
    }
}

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

// 조회 후 원자적 삭제
[apiInstance getAndDeleteWith:bTreeGetRequest
              completionHandler: ^(ApiResultCollectionResponseListBTreeElementResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeGetRequest = ; // {BTreeGetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeGetRequest = new BTreeGetRequest(); // BTreeGetRequest | 

            try {
                // 조회 후 원자적 삭제
                ApiResultCollectionResponseListBTreeElementResponse result = apiInstance.getAndDelete(bTreeGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.getAndDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeGetRequest = ; // BTreeGetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeGetRequest = WWW::OPenAPIClient::Object::BTreeGetRequest->new(); # BTreeGetRequest | 

eval {
    my $result = $api_instance->getAndDelete(bTreeGetRequest => $bTreeGetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->getAndDelete: $@\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.BTreeApi()
bTreeGetRequest =  # BTreeGetRequest | 

try:
    # 조회 후 원자적 삭제
    api_response = api_instance.get_and_delete(bTreeGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->getAndDelete: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeGetRequest = ; // BTreeGetRequest

    let mut context = BTreeApi::Context::default();
    let result = client.getAndDelete(bTreeGetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeGetBulkRequest bTreeGetBulkRequest = ; // BTreeGetBulkRequest | 

        try {
            ApiResultMapStringCollectionResponseListBTreeElementResponse result = apiInstance.getBulk(bTreeGetBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeGetBulkRequest bTreeGetBulkRequest = new BTreeGetBulkRequest(); // BTreeGetBulkRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeGetBulkRequest bTreeGetBulkRequest = ; // BTreeGetBulkRequest | 

        try {
            ApiResultMapStringCollectionResponseListBTreeElementResponse result = apiInstance.getBulk(bTreeGetBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 B+Tree 조회
[apiInstance getBulkWith:bTreeGetBulkRequest
              completionHandler: ^(ApiResultMapStringCollectionResponseListBTreeElementResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeGetBulkRequest = ; // {BTreeGetBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeGetBulkRequest = new BTreeGetBulkRequest(); // BTreeGetBulkRequest | 

            try {
                // 여러 B+Tree 조회
                ApiResultMapStringCollectionResponseListBTreeElementResponse result = apiInstance.getBulk(bTreeGetBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.getBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeGetBulkRequest = ; // BTreeGetBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeGetBulkRequest = WWW::OPenAPIClient::Object::BTreeGetBulkRequest->new(); # BTreeGetBulkRequest | 

eval {
    my $result = $api_instance->getBulk(bTreeGetBulkRequest => $bTreeGetBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->getBulk: $@\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.BTreeApi()
bTreeGetBulkRequest =  # BTreeGetBulkRequest | 

try:
    # 여러 B+Tree 조회
    api_response = api_instance.get_bulk(bTreeGetBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->getBulk: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeGetBulkRequest = ; // BTreeGetBulkRequest

    let mut context = BTreeApi::Context::default();
    let result = client.getBulk(bTreeGetBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeByPositionRequest bTreeByPositionRequest = ; // BTreeByPositionRequest | 

        try {
            ApiResultCollectionResponseMapIntegerBTreeElementResponse result = apiInstance.getByPosition(bTreeByPositionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getByPosition");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeByPositionRequest bTreeByPositionRequest = new BTreeByPositionRequest(); // BTreeByPositionRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeByPositionRequest bTreeByPositionRequest = ; // BTreeByPositionRequest | 

        try {
            ApiResultCollectionResponseMapIntegerBTreeElementResponse result = apiInstance.getByPosition(bTreeByPositionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getByPosition");
            e.printStackTrace();
        }
    }
}

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

// 위치 기준 조회
[apiInstance getByPositionWith:bTreeByPositionRequest
              completionHandler: ^(ApiResultCollectionResponseMapIntegerBTreeElementResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeByPositionRequest = ; // {BTreeByPositionRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeByPositionRequest = new BTreeByPositionRequest(); // BTreeByPositionRequest | 

            try {
                // 위치 기준 조회
                ApiResultCollectionResponseMapIntegerBTreeElementResponse result = apiInstance.getByPosition(bTreeByPositionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.getByPosition: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeByPositionRequest = ; // BTreeByPositionRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeByPositionRequest = WWW::OPenAPIClient::Object::BTreeByPositionRequest->new(); # BTreeByPositionRequest | 

eval {
    my $result = $api_instance->getByPosition(bTreeByPositionRequest => $bTreeByPositionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->getByPosition: $@\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.BTreeApi()
bTreeByPositionRequest =  # BTreeByPositionRequest | 

try:
    # 위치 기준 조회
    api_response = api_instance.get_by_position(bTreeByPositionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->getByPosition: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeByPositionRequest = ; // BTreeByPositionRequest

    let mut context = BTreeApi::Context::default();
    let result = client.getByPosition(bTreeByPositionRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeCountRequest bTreeCountRequest = ; // BTreeCountRequest | 

        try {
            ApiResultCollectionResponseInteger result = apiInstance.getItemCount(bTreeCountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getItemCount");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeCountRequest bTreeCountRequest = new BTreeCountRequest(); // BTreeCountRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeCountRequest bTreeCountRequest = ; // BTreeCountRequest | 

        try {
            ApiResultCollectionResponseInteger result = apiInstance.getItemCount(bTreeCountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#getItemCount");
            e.printStackTrace();
        }
    }
}

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

// 범위 내 요소 개수
[apiInstance getItemCountWith:bTreeCountRequest
              completionHandler: ^(ApiResultCollectionResponseInteger output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeCountRequest = ; // {BTreeCountRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeCountRequest = new BTreeCountRequest(); // BTreeCountRequest | 

            try {
                // 범위 내 요소 개수
                ApiResultCollectionResponseInteger result = apiInstance.getItemCount(bTreeCountRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.getItemCount: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeCountRequest = ; // BTreeCountRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeCountRequest = WWW::OPenAPIClient::Object::BTreeCountRequest->new(); # BTreeCountRequest | 

eval {
    my $result = $api_instance->getItemCount(bTreeCountRequest => $bTreeCountRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->getItemCount: $@\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.BTreeApi()
bTreeCountRequest =  # BTreeCountRequest | 

try:
    # 범위 내 요소 개수
    api_response = api_instance.get_item_count(bTreeCountRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->getItemCount: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeCountRequest = ; // BTreeCountRequest

    let mut context = BTreeApi::Context::default();
    let result = client.getItemCount(bTreeCountRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeCounterRequest bTreeCounterRequest = ; // BTreeCounterRequest | 

        try {
            ApiResultCollectionResponseString result = apiInstance.incr(bTreeCounterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#incr");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeCounterRequest bTreeCounterRequest = new BTreeCounterRequest(); // BTreeCounterRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeCounterRequest bTreeCounterRequest = ; // BTreeCounterRequest | 

        try {
            ApiResultCollectionResponseString result = apiInstance.incr(bTreeCounterRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#incr");
            e.printStackTrace();
        }
    }
}

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

// 요소 값 증감
[apiInstance incrWith:bTreeCounterRequest
              completionHandler: ^(ApiResultCollectionResponseString output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeCounterRequest = ; // {BTreeCounterRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeCounterRequest = new BTreeCounterRequest(); // BTreeCounterRequest | 

            try {
                // 요소 값 증감
                ApiResultCollectionResponseString result = apiInstance.incr(bTreeCounterRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.incr: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeCounterRequest = ; // BTreeCounterRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeCounterRequest = WWW::OPenAPIClient::Object::BTreeCounterRequest->new(); # BTreeCounterRequest | 

eval {
    my $result = $api_instance->incr(bTreeCounterRequest => $bTreeCounterRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->incr: $@\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.BTreeApi()
bTreeCounterRequest =  # BTreeCounterRequest | 

try:
    # 요소 값 증감
    api_response = api_instance.incr(bTreeCounterRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->incr: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeCounterRequest = ; // BTreeCounterRequest

    let mut context = BTreeApi::Context::default();
    let result = client.incr(bTreeCounterRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#insert");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeStoreRequest bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.insert(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#insert");
            e.printStackTrace();
        }
    }
}

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

// B+Tree 요소 저장
[apiInstance insertWith:bTreeStoreRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeStoreRequest = ; // {BTreeStoreRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

            try {
                // B+Tree 요소 저장
                ApiResultCollectionResponseBoolean result = apiInstance.insert(bTreeStoreRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.insert: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeStoreRequest = ; // BTreeStoreRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeStoreRequest = WWW::OPenAPIClient::Object::BTreeStoreRequest->new(); # BTreeStoreRequest | 

eval {
    my $result = $api_instance->insert(bTreeStoreRequest => $bTreeStoreRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->insert: $@\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.BTreeApi()
bTreeStoreRequest =  # BTreeStoreRequest | 

try:
    # B+Tree 요소 저장
    api_response = api_instance.insert(bTreeStoreRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->insert: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeStoreRequest = ; // BTreeStoreRequest

    let mut context = BTreeApi::Context::default();
    let result = client.insert(bTreeStoreRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBTreeTrimmedResponse result = apiInstance.insertAndGetTrimmed(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#insertAndGetTrimmed");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeStoreRequest bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBTreeTrimmedResponse result = apiInstance.insertAndGetTrimmed(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#insertAndGetTrimmed");
            e.printStackTrace();
        }
    }
}

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

// B+Tree 요소 저장
[apiInstance insertAndGetTrimmedWith:bTreeStoreRequest
              completionHandler: ^(ApiResultCollectionResponseBTreeTrimmedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeStoreRequest = ; // {BTreeStoreRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

            try {
                // B+Tree 요소 저장
                ApiResultCollectionResponseBTreeTrimmedResponse result = apiInstance.insertAndGetTrimmed(bTreeStoreRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.insertAndGetTrimmed: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeStoreRequest = ; // BTreeStoreRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeStoreRequest = WWW::OPenAPIClient::Object::BTreeStoreRequest->new(); # BTreeStoreRequest | 

eval {
    my $result = $api_instance->insertAndGetTrimmed(bTreeStoreRequest => $bTreeStoreRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->insertAndGetTrimmed: $@\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.BTreeApi()
bTreeStoreRequest =  # BTreeStoreRequest | 

try:
    # B+Tree 요소 저장
    api_response = api_instance.insert_and_get_trimmed(bTreeStoreRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->insertAndGetTrimmed: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeStoreRequest = ; // BTreeStoreRequest

    let mut context = BTreeApi::Context::default();
    let result = client.insertAndGetTrimmed(bTreeStoreRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeInsertBulkRequest bTreeInsertBulkRequest = ; // BTreeInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(bTreeInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#insertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeInsertBulkRequest bTreeInsertBulkRequest = new BTreeInsertBulkRequest(); // BTreeInsertBulkRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeInsertBulkRequest bTreeInsertBulkRequest = ; // BTreeInsertBulkRequest | 

        try {
            ApiResultBulkResponse result = apiInstance.insertBulk(bTreeInsertBulkRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#insertBulk");
            e.printStackTrace();
        }
    }
}

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

// 여러 B+Tree에 요소 삽입
[apiInstance insertBulkWith:bTreeInsertBulkRequest
              completionHandler: ^(ApiResultBulkResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeInsertBulkRequest = ; // {BTreeInsertBulkRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeInsertBulkRequest = new BTreeInsertBulkRequest(); // BTreeInsertBulkRequest | 

            try {
                // 여러 B+Tree에 요소 삽입
                ApiResultBulkResponse result = apiInstance.insertBulk(bTreeInsertBulkRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.insertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeInsertBulkRequest = ; // BTreeInsertBulkRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeInsertBulkRequest = WWW::OPenAPIClient::Object::BTreeInsertBulkRequest->new(); # BTreeInsertBulkRequest | 

eval {
    my $result = $api_instance->insertBulk(bTreeInsertBulkRequest => $bTreeInsertBulkRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->insertBulk: $@\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.BTreeApi()
bTreeInsertBulkRequest =  # BTreeInsertBulkRequest | 

try:
    # 여러 B+Tree에 요소 삽입
    api_response = api_instance.insert_bulk(bTreeInsertBulkRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->insertBulk: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeInsertBulkRequest = ; // BTreeInsertBulkRequest

    let mut context = BTreeApi::Context::default();
    let result = client.insertBulk(bTreeInsertBulkRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreePipedInsertRequest bTreePipedInsertRequest = ; // BTreePipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(bTreePipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreePipedInsertRequest bTreePipedInsertRequest = new BTreePipedInsertRequest(); // BTreePipedInsertRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreePipedInsertRequest bTreePipedInsertRequest = ; // BTreePipedInsertRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(bTreePipedInsertRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#pipedInsertBulk");
            e.printStackTrace();
        }
    }
}

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

// piped-insert-bulk
[apiInstance pipedInsertBulkWith:bTreePipedInsertRequest
              completionHandler: ^(ApiResultIndexedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreePipedInsertRequest = ; // {BTreePipedInsertRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreePipedInsertRequest = new BTreePipedInsertRequest(); // BTreePipedInsertRequest | 

            try {
                // piped-insert-bulk
                ApiResultIndexedResponse result = apiInstance.pipedInsertBulk(bTreePipedInsertRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.pipedInsertBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreePipedInsertRequest = ; // BTreePipedInsertRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreePipedInsertRequest = WWW::OPenAPIClient::Object::BTreePipedInsertRequest->new(); # BTreePipedInsertRequest | 

eval {
    my $result = $api_instance->pipedInsertBulk(bTreePipedInsertRequest => $bTreePipedInsertRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->pipedInsertBulk: $@\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.BTreeApi()
bTreePipedInsertRequest =  # BTreePipedInsertRequest | 

try:
    # piped-insert-bulk
    api_response = api_instance.piped_insert_bulk(bTreePipedInsertRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->pipedInsertBulk: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreePipedInsertRequest = ; // BTreePipedInsertRequest

    let mut context = BTreeApi::Context::default();
    let result = client.pipedInsertBulk(bTreePipedInsertRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreePipedUpdateRequest bTreePipedUpdateRequest = ; // BTreePipedUpdateRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedUpdateBulk(bTreePipedUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#pipedUpdateBulk");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreePipedUpdateRequest bTreePipedUpdateRequest = new BTreePipedUpdateRequest(); // BTreePipedUpdateRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreePipedUpdateRequest bTreePipedUpdateRequest = ; // BTreePipedUpdateRequest | 

        try {
            ApiResultIndexedResponse result = apiInstance.pipedUpdateBulk(bTreePipedUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#pipedUpdateBulk");
            e.printStackTrace();
        }
    }
}

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

// piped-update-bulk
[apiInstance pipedUpdateBulkWith:bTreePipedUpdateRequest
              completionHandler: ^(ApiResultIndexedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreePipedUpdateRequest = ; // {BTreePipedUpdateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreePipedUpdateRequest = new BTreePipedUpdateRequest(); // BTreePipedUpdateRequest | 

            try {
                // piped-update-bulk
                ApiResultIndexedResponse result = apiInstance.pipedUpdateBulk(bTreePipedUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.pipedUpdateBulk: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreePipedUpdateRequest = ; // BTreePipedUpdateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreePipedUpdateRequest = WWW::OPenAPIClient::Object::BTreePipedUpdateRequest->new(); # BTreePipedUpdateRequest | 

eval {
    my $result = $api_instance->pipedUpdateBulk(bTreePipedUpdateRequest => $bTreePipedUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->pipedUpdateBulk: $@\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.BTreeApi()
bTreePipedUpdateRequest =  # BTreePipedUpdateRequest | 

try:
    # piped-update-bulk
    api_response = api_instance.piped_update_bulk(bTreePipedUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->pipedUpdateBulk: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreePipedUpdateRequest = ; // BTreePipedUpdateRequest

    let mut context = BTreeApi::Context::default();
    let result = client.pipedUpdateBulk(bTreePipedUpdateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeSMGetRequest bTreeSMGetRequest = ; // BTreeSMGetRequest | 

        try {
            ApiResultCollectionResponseBTreeSMGetResponse result = apiInstance.smget(bTreeSMGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#smget");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeSMGetRequest bTreeSMGetRequest = new BTreeSMGetRequest(); // BTreeSMGetRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeSMGetRequest bTreeSMGetRequest = ; // BTreeSMGetRequest | 

        try {
            ApiResultCollectionResponseBTreeSMGetResponse result = apiInstance.smget(bTreeSMGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#smget");
            e.printStackTrace();
        }
    }
}

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

// 정렬 병합 조회
[apiInstance smgetWith:bTreeSMGetRequest
              completionHandler: ^(ApiResultCollectionResponseBTreeSMGetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeSMGetRequest = ; // {BTreeSMGetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeSMGetRequest = new BTreeSMGetRequest(); // BTreeSMGetRequest | 

            try {
                // 정렬 병합 조회
                ApiResultCollectionResponseBTreeSMGetResponse result = apiInstance.smget(bTreeSMGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.smget: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeSMGetRequest = ; // BTreeSMGetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeSMGetRequest = WWW::OPenAPIClient::Object::BTreeSMGetRequest->new(); # BTreeSMGetRequest | 

eval {
    my $result = $api_instance->smget(bTreeSMGetRequest => $bTreeSMGetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->smget: $@\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.BTreeApi()
bTreeSMGetRequest =  # BTreeSMGetRequest | 

try:
    # 정렬 병합 조회
    api_response = api_instance.smget(bTreeSMGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->smget: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeSMGetRequest = ; // BTreeSMGetRequest

    let mut context = BTreeApi::Context::default();
    let result = client.smget(bTreeSMGetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeUpdateRequest bTreeUpdateRequest = ; // BTreeUpdateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.update(bTreeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#update");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeUpdateRequest bTreeUpdateRequest = new BTreeUpdateRequest(); // BTreeUpdateRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeUpdateRequest bTreeUpdateRequest = ; // BTreeUpdateRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.update(bTreeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#update");
            e.printStackTrace();
        }
    }
}

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

// 값과 EFlag 수정
[apiInstance updateWith:bTreeUpdateRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeUpdateRequest = ; // {BTreeUpdateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeUpdateRequest = new BTreeUpdateRequest(); // BTreeUpdateRequest | 

            try {
                // 값과 EFlag 수정
                ApiResultCollectionResponseBoolean result = apiInstance.update(bTreeUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.update: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeUpdateRequest = ; // BTreeUpdateRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeUpdateRequest = WWW::OPenAPIClient::Object::BTreeUpdateRequest->new(); # BTreeUpdateRequest | 

eval {
    my $result = $api_instance->update(bTreeUpdateRequest => $bTreeUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->update: $@\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.BTreeApi()
bTreeUpdateRequest =  # BTreeUpdateRequest | 

try:
    # 값과 EFlag 수정
    api_response = api_instance.update(bTreeUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->update: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeUpdateRequest = ; // BTreeUpdateRequest

    let mut context = BTreeApi::Context::default();
    let result = client.update(bTreeUpdateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.upsert(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#upsert");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeStoreRequest bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.upsert(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#upsert");
            e.printStackTrace();
        }
    }
}

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

// B+Tree 요소 저장
[apiInstance upsertWith:bTreeStoreRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeStoreRequest = ; // {BTreeStoreRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

            try {
                // B+Tree 요소 저장
                ApiResultCollectionResponseBoolean result = apiInstance.upsert(bTreeStoreRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.upsert: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeStoreRequest = ; // BTreeStoreRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeStoreRequest = WWW::OPenAPIClient::Object::BTreeStoreRequest->new(); # BTreeStoreRequest | 

eval {
    my $result = $api_instance->upsert(bTreeStoreRequest => $bTreeStoreRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->upsert: $@\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.BTreeApi()
bTreeStoreRequest =  # BTreeStoreRequest | 

try:
    # B+Tree 요소 저장
    api_response = api_instance.upsert(bTreeStoreRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->upsert: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeStoreRequest = ; // BTreeStoreRequest

    let mut context = BTreeApi::Context::default();
    let result = client.upsert(bTreeStoreRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBTreeTrimmedResponse result = apiInstance.upsertAndGetTrimmed(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#upsertAndGetTrimmed");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BTreeStoreRequest bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

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

import org.openapitools.client.api.BTreeApi;

public class BTreeApiExample {
    public static void main(String[] args) {
        BTreeApi apiInstance = new BTreeApi();
        BTreeStoreRequest bTreeStoreRequest = ; // BTreeStoreRequest | 

        try {
            ApiResultCollectionResponseBTreeTrimmedResponse result = apiInstance.upsertAndGetTrimmed(bTreeStoreRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BTreeApi#upsertAndGetTrimmed");
            e.printStackTrace();
        }
    }
}

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

// B+Tree 요소 저장
[apiInstance upsertAndGetTrimmedWith:bTreeStoreRequest
              completionHandler: ^(ApiResultCollectionResponseBTreeTrimmedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.BTreeApi()
var bTreeStoreRequest = ; // {BTreeStoreRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BTreeApi();
            var bTreeStoreRequest = new BTreeStoreRequest(); // BTreeStoreRequest | 

            try {
                // B+Tree 요소 저장
                ApiResultCollectionResponseBTreeTrimmedResponse result = apiInstance.upsertAndGetTrimmed(bTreeStoreRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BTreeApi.upsertAndGetTrimmed: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BTreeApi();
$bTreeStoreRequest = ; // BTreeStoreRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BTreeApi->new();
my $bTreeStoreRequest = WWW::OPenAPIClient::Object::BTreeStoreRequest->new(); # BTreeStoreRequest | 

eval {
    my $result = $api_instance->upsertAndGetTrimmed(bTreeStoreRequest => $bTreeStoreRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BTreeApi->upsertAndGetTrimmed: $@\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.BTreeApi()
bTreeStoreRequest =  # BTreeStoreRequest | 

try:
    # B+Tree 요소 저장
    api_response = api_instance.upsert_and_get_trimmed(bTreeStoreRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BTreeApi->upsertAndGetTrimmed: %s\n" % e)

extern crate BTreeApi;

pub fn main() {
    let bTreeStoreRequest = ; // BTreeStoreRequest

    let mut context = BTreeApi::Context::default();
    let result = client.upsertAndGetTrimmed(bTreeStoreRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ItemApi apiInstance = new ItemApi();
        GetAttributesRequest getAttributesRequest = ; // GetAttributesRequest | 

        try {
            ApiResultCollectionResponseAttributesResponse result = apiInstance.getAttributes(getAttributesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ItemApi#getAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetAttributesRequest getAttributesRequest = new GetAttributesRequest(); // GetAttributesRequest | 

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

import org.openapitools.client.api.ItemApi;

public class ItemApiExample {
    public static void main(String[] args) {
        ItemApi apiInstance = new ItemApi();
        GetAttributesRequest getAttributesRequest = ; // GetAttributesRequest | 

        try {
            ApiResultCollectionResponseAttributesResponse result = apiInstance.getAttributes(getAttributesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ItemApi#getAttributes");
            e.printStackTrace();
        }
    }
}

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

// 아이템 속성 조회
[apiInstance getAttributesWith:getAttributesRequest
              completionHandler: ^(ApiResultCollectionResponseAttributesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ItemApi()
var getAttributesRequest = ; // {GetAttributesRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ItemApi();
            var getAttributesRequest = new GetAttributesRequest(); // GetAttributesRequest | 

            try {
                // 아이템 속성 조회
                ApiResultCollectionResponseAttributesResponse result = apiInstance.getAttributes(getAttributesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ItemApi.getAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ItemApi();
$getAttributesRequest = ; // GetAttributesRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ItemApi->new();
my $getAttributesRequest = WWW::OPenAPIClient::Object::GetAttributesRequest->new(); # GetAttributesRequest | 

eval {
    my $result = $api_instance->getAttributes(getAttributesRequest => $getAttributesRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ItemApi->getAttributes: $@\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.ItemApi()
getAttributesRequest =  # GetAttributesRequest | 

try:
    # 아이템 속성 조회
    api_response = api_instance.get_attributes(getAttributesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ItemApi->getAttributes: %s\n" % e)

extern crate ItemApi;

pub fn main() {
    let getAttributesRequest = ; // GetAttributesRequest

    let mut context = ItemApi::Context::default();
    let result = client.getAttributes(getAttributesRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ItemApi apiInstance = new ItemApi();
        SetAttributesRequest setAttributesRequest = ; // SetAttributesRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.setAttributes(setAttributesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ItemApi#setAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetAttributesRequest setAttributesRequest = new SetAttributesRequest(); // SetAttributesRequest | 

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

import org.openapitools.client.api.ItemApi;

public class ItemApiExample {
    public static void main(String[] args) {
        ItemApi apiInstance = new ItemApi();
        SetAttributesRequest setAttributesRequest = ; // SetAttributesRequest | 

        try {
            ApiResultCollectionResponseBoolean result = apiInstance.setAttributes(setAttributesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ItemApi#setAttributes");
            e.printStackTrace();
        }
    }
}

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

// 아이템 속성 변경
[apiInstance setAttributesWith:setAttributesRequest
              completionHandler: ^(ApiResultCollectionResponseBoolean output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.ItemApi()
var setAttributesRequest = ; // {SetAttributesRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ItemApi();
            var setAttributesRequest = new SetAttributesRequest(); // SetAttributesRequest | 

            try {
                // 아이템 속성 변경
                ApiResultCollectionResponseBoolean result = apiInstance.setAttributes(setAttributesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ItemApi.setAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ItemApi();
$setAttributesRequest = ; // SetAttributesRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ItemApi->new();
my $setAttributesRequest = WWW::OPenAPIClient::Object::SetAttributesRequest->new(); # SetAttributesRequest | 

eval {
    my $result = $api_instance->setAttributes(setAttributesRequest => $setAttributesRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ItemApi->setAttributes: $@\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.ItemApi()
setAttributesRequest =  # SetAttributesRequest | 

try:
    # 아이템 속성 변경
    api_response = api_instance.set_attributes(setAttributesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ItemApi->setAttributes: %s\n" % e)

extern crate ItemApi;

pub fn main() {
    let setAttributesRequest = ; // SetAttributesRequest

    let mut context = ItemApi::Context::default();
    let result = client.setAttributes(setAttributesRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CacheApi apiInstance = new CacheApi();
        FlushRequest flushRequest = ; // FlushRequest | 

        try {
            ApiResultBooleanResponse result = apiInstance.flush(flushRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CacheApi#flush");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final FlushRequest flushRequest = new FlushRequest(); // FlushRequest | 

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

import org.openapitools.client.api.CacheApi;

public class CacheApiExample {
    public static void main(String[] args) {
        CacheApi apiInstance = new CacheApi();
        FlushRequest flushRequest = ; // FlushRequest | 

        try {
            ApiResultBooleanResponse result = apiInstance.flush(flushRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CacheApi#flush");
            e.printStackTrace();
        }
    }
}

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

// 전체 또는 prefix 아이템 삭제
[apiInstance flushWith:flushRequest
              completionHandler: ^(ApiResultBooleanResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ArcusHttpApi = require('arcus_http_api');

// Create an instance of the API class
var api = new ArcusHttpApi.CacheApi()
var flushRequest = ; // {FlushRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CacheApi();
            var flushRequest = new FlushRequest(); // FlushRequest | 

            try {
                // 전체 또는 prefix 아이템 삭제
                ApiResultBooleanResponse result = apiInstance.flush(flushRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CacheApi.flush: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CacheApi();
$flushRequest = ; // FlushRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CacheApi->new();
my $flushRequest = WWW::OPenAPIClient::Object::FlushRequest->new(); # FlushRequest | 

eval {
    my $result = $api_instance->flush(flushRequest => $flushRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CacheApi->flush: $@\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.CacheApi()
flushRequest =  # FlushRequest | 

try:
    # 전체 또는 prefix 아이템 삭제
    api_response = api_instance.flush(flushRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CacheApi->flush: %s\n" % e)

extern crate CacheApi;

pub fn main() {
    let flushRequest = ; // FlushRequest

    let mut context = CacheApi::Context::default();
    let result = client.flush(flushRequest, &context).wait();

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