GS2-SkillTree SDK API Reference

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DescribeNamespacesRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->describeNamespaces(
        (new DescribeNamespacesRequest())
            ->withNamePrefix(null)
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DescribeNamespacesRequest;
import io.gs2.skillTree.result.DescribeNamespacesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DescribeNamespacesResult result = client.describeNamespaces(
        new DescribeNamespacesRequest()
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    List<Namespace> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2SkillTree.Request.DescribeNamespacesRequest()
        .WithNamePrefix(null)
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.describeNamespaces(
        new Gs2SkillTree.DescribeNamespacesRequest()
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.describe_namespaces(
        skill_tree.DescribeNamespacesRequest()
            .with_name_prefix(None)
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.describe_namespaces({
    namePrefix=nil,
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('skill_tree')

api_result_handler = client.describe_namespaces_async({
    namePrefix=nil,
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\CreateNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName("namespace-0001")
            ->withDescription(null)
            ->withTransactionSetting((new \Gs2\SkillTree\Model\TransactionSetting())
                ->withEnableAutoRun(false)
                ->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            ->withReleaseScript(null)
            ->withRestrainScript(null)
            ->withLogSetting((new \Gs2\SkillTree\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.CreateNamespaceRequest;
import io.gs2.skillTree.result.CreateNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(new io.gs2.skillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new io.gs2.skillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2SkillTree.Request.CreateNamespaceRequest()
        .WithName("namespace-0001")
        .WithDescription(null)
        .WithTransactionSetting(new Gs2.Gs2SkillTree.Model.TransactionSetting()
            .WithEnableAutoRun(false)
            .WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
        .WithReleaseScript(null)
        .WithRestrainScript(null)
        .WithLogSetting(new Gs2.Gs2SkillTree.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.createNamespace(
        new Gs2SkillTree.CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(new Gs2SkillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new Gs2SkillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.create_namespace(
        skill_tree.CreateNamespaceRequest()
            .with_name('namespace-0001')
            .with_description(None)
            .with_transaction_setting(
                skill_tree.TransactionSetting()
                    .with_enable_auto_run(False)
                    .with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
            .with_release_script(None)
            .with_restrain_script(None)
            .with_log_setting(
                skill_tree.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.create_namespace({
    name="namespace-0001",
    description=nil,
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
    },
    releaseScript=nil,
    restrainScript=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.create_namespace_async({
    name="namespace-0001",
    description=nil,
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
    },
    releaseScript=nil,
    restrainScript=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetNamespaceStatusRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName("namespace-0001")
    );
    $status = $result->getStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetNamespaceStatusRequest;
import io.gs2.skillTree.result.GetNamespaceStatusResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetNamespaceStatusResult result = client.getNamespaceStatus(
        new GetNamespaceStatusRequest()
            .withNamespaceName("namespace-0001")
    );
    String status = result.getStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2SkillTree.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getNamespaceStatus(
        new Gs2SkillTree.GetNamespaceStatusRequest()
            .withNamespaceName("namespace-0001")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_namespace_status(
        skill_tree.GetNamespaceStatusRequest()
            .with_namespace_name('namespace-0001')
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_namespace_status({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
status = result.status;

client = gs2('skill_tree')

api_result_handler = client.get_namespace_status_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
status = result.status;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetNamespaceRequest;
import io.gs2.skillTree.result.GetNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetNamespaceResult result = client.getNamespace(
        new GetNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2SkillTree.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getNamespace(
        new Gs2SkillTree.GetNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_namespace(
        skill_tree.GetNamespaceRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_namespace({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.get_namespace_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\UpdateNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName("namespace-0001")
            ->withDescription("description1")
            ->withTransactionSetting((new \Gs2\SkillTree\Model\TransactionSetting())
                ->withEnableAutoRun(false)
                ->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            ->withReleaseScript(null)
            ->withRestrainScript(null)
            ->withLogSetting((new \Gs2\SkillTree\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.UpdateNamespaceRequest;
import io.gs2.skillTree.result.UpdateNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(new io.gs2.skillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new io.gs2.skillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2SkillTree.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace-0001")
        .WithDescription("description1")
        .WithTransactionSetting(new Gs2.Gs2SkillTree.Model.TransactionSetting()
            .WithEnableAutoRun(false)
            .WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
        .WithReleaseScript(null)
        .WithRestrainScript(null)
        .WithLogSetting(new Gs2.Gs2SkillTree.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.updateNamespace(
        new Gs2SkillTree.UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(new Gs2SkillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new Gs2SkillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.update_namespace(
        skill_tree.UpdateNamespaceRequest()
            .with_namespace_name('namespace-0001')
            .with_description('description1')
            .with_transaction_setting(
                skill_tree.TransactionSetting()
                    .with_enable_auto_run(False)
                    .with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
            .with_release_script(None)
            .with_restrain_script(None)
            .with_log_setting(
                skill_tree.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.update_namespace({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
    },
    releaseScript=nil,
    restrainScript=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
    },
    releaseScript=nil,
    restrainScript=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DeleteNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DeleteNamespaceRequest;
import io.gs2.skillTree.result.DeleteNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DeleteNamespaceResult result = client.deleteNamespace(
        new DeleteNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2SkillTree.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.deleteNamespace(
        new Gs2SkillTree.DeleteNamespaceRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.delete_namespace(
        skill_tree.DeleteNamespaceRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.delete_namespace({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.delete_namespace_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetServiceVersionRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getServiceVersion(
        (new GetServiceVersionRequest())
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetServiceVersionRequest;
import io.gs2.skillTree.result.GetServiceVersionResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetServiceVersionResult result = client.getServiceVersion(
        new GetServiceVersionRequest()
    );
    String item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetServiceVersionResult> asyncResult = null;
yield return client.GetServiceVersion(
    new Gs2.Gs2SkillTree.Request.GetServiceVersionRequest(),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getServiceVersion(
        new Gs2SkillTree.GetServiceVersionRequest()
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_service_version(
        skill_tree.GetServiceVersionRequest()
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_service_version({
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.get_service_version_async({
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DumpUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->dumpUserDataByUserId(
        (new DumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DumpUserDataByUserIdRequest;
import io.gs2.skillTree.result.DumpUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DumpUserDataByUserIdResult result = client.dumpUserDataByUserId(
        new DumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DumpUserDataByUserIdResult> asyncResult = null;
yield return client.DumpUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.DumpUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.dumpUserDataByUserId(
        new Gs2SkillTree.DumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.dump_user_data_by_user_id(
        skill_tree.DumpUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.dump_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

client = gs2('skill_tree')

api_result_handler = client.dump_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\CheckDumpUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->checkDumpUserDataByUserId(
        (new CheckDumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.skillTree.result.CheckDumpUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    CheckDumpUserDataByUserIdResult result = client.checkDumpUserDataByUserId(
        new CheckDumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CheckDumpUserDataByUserIdResult> asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.CheckDumpUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.checkDumpUserDataByUserId(
        new Gs2SkillTree.CheckDumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const url = result.getUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.check_dump_user_data_by_user_id(
        skill_tree.CheckDumpUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.check_dump_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
url = result.url;

client = gs2('skill_tree')

api_result_handler = client.check_dump_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
url = result.url;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\CleanUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->cleanUserDataByUserId(
        (new CleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.CleanUserDataByUserIdRequest;
import io.gs2.skillTree.result.CleanUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    CleanUserDataByUserIdResult result = client.cleanUserDataByUserId(
        new CleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CleanUserDataByUserIdResult> asyncResult = null;
yield return client.CleanUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.CleanUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.cleanUserDataByUserId(
        new Gs2SkillTree.CleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.clean_user_data_by_user_id(
        skill_tree.CleanUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.clean_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

client = gs2('skill_tree')

api_result_handler = client.clean_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\CheckCleanUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->checkCleanUserDataByUserId(
        (new CheckCleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.skillTree.result.CheckCleanUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    CheckCleanUserDataByUserIdResult result = client.checkCleanUserDataByUserId(
        new CheckCleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CheckCleanUserDataByUserIdResult> asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.CheckCleanUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.checkCleanUserDataByUserId(
        new Gs2SkillTree.CheckCleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.check_clean_user_data_by_user_id(
        skill_tree.CheckCleanUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.check_clean_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

client = gs2('skill_tree')

api_result_handler = client.check_clean_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\PrepareImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->prepareImportUserDataByUserId(
        (new PrepareImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.skillTree.result.PrepareImportUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    PrepareImportUserDataByUserIdResult result = client.prepareImportUserDataByUserId(
        new PrepareImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    String uploadToken = result.getUploadToken();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.PrepareImportUserDataByUserIdResult> asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.PrepareImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.prepareImportUserDataByUserId(
        new Gs2SkillTree.PrepareImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const uploadToken = result.getUploadToken();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.prepare_import_user_data_by_user_id(
        skill_tree.PrepareImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.prepare_import_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

client = gs2('skill_tree')

api_result_handler = client.prepare_import_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\ImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->importUserDataByUserId(
        (new ImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.ImportUserDataByUserIdRequest;
import io.gs2.skillTree.result.ImportUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    ImportUserDataByUserIdResult result = client.importUserDataByUserId(
        new ImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ImportUserDataByUserIdResult> asyncResult = null;
yield return client.ImportUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.ImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithUploadToken("upload-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.importUserDataByUserId(
        new Gs2SkillTree.ImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.import_user_data_by_user_id(
        skill_tree.ImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_upload_token('upload-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.import_user_data_by_user_id({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

client = gs2('skill_tree')

api_result_handler = client.import_user_data_by_user_id_async({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\CheckImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->checkImportUserDataByUserId(
        (new CheckImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.CheckImportUserDataByUserIdRequest;
import io.gs2.skillTree.result.CheckImportUserDataByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    CheckImportUserDataByUserIdResult result = client.checkImportUserDataByUserId(
        new CheckImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CheckImportUserDataByUserIdResult> asyncResult = null;
yield return client.CheckImportUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.CheckImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithUploadToken("upload-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.checkImportUserDataByUserId(
        new Gs2SkillTree.CheckImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
    const url = result.getUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.check_import_user_data_by_user_id(
        skill_tree.CheckImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_upload_token('upload-0001')
            .with_time_offset_token(None)
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.check_import_user_data_by_user_id({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
url = result.url;

client = gs2('skill_tree')

api_result_handler = client.check_import_user_data_by_user_id_async({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
url = result.url;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\MarkReleaseByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->markReleaseByUserId(
        (new MarkReleaseByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPropertyId("property-0001")
            ->withNodeModelNames([
                "node-0001",
            ])
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.MarkReleaseByUserIdRequest;
import io.gs2.skillTree.result.MarkReleaseByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    MarkReleaseByUserIdResult result = client.markReleaseByUserId(
        new MarkReleaseByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.MarkReleaseByUserIdResult> asyncResult = null;
yield return client.MarkReleaseByUserId(
    new Gs2.Gs2SkillTree.Request.MarkReleaseByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPropertyId("property-0001")
        .WithNodeModelNames(new string[] {
            "node-0001",
        })
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.markReleaseByUserId(
        new Gs2SkillTree.MarkReleaseByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames([
                "node-0001",
            ])
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.mark_release_by_user_id(
        skill_tree.MarkReleaseByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_property_id('property-0001')
            .with_node_model_names([
                'node-0001',
            ])
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.mark_release_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.mark_release_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\ReleaseRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->release(
        (new ReleaseRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withPropertyId("property-0001")
            ->withNodeModelNames([
                "node-0001",
            ])
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.ReleaseRequest;
import io.gs2.skillTree.result.ReleaseResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    ReleaseResult result = client.release(
        new ReleaseRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
            .withConfig(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ReleaseResult> asyncResult = null;
yield return client.Release(
    new Gs2.Gs2SkillTree.Request.ReleaseRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithPropertyId("property-0001")
        .WithNodeModelNames(new string[] {
            "node-0001",
        })
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.release(
        new Gs2SkillTree.ReleaseRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames([
                "node-0001",
            ])
            .withConfig(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.release(
        skill_tree.ReleaseRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_property_id('property-0001')
            .with_node_model_names([
                'node-0001',
            ])
            .with_config(None)
    )
    item = result.item
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.release({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

client = gs2('skill_tree')

api_result_handler = client.release_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\ReleaseByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->releaseByUserId(
        (new ReleaseByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPropertyId("property-0001")
            ->withNodeModelNames([
                "node-0001",
            ])
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.ReleaseByUserIdRequest;
import io.gs2.skillTree.result.ReleaseByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    ReleaseByUserIdResult result = client.releaseByUserId(
        new ReleaseByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ReleaseByUserIdResult> asyncResult = null;
yield return client.ReleaseByUserId(
    new Gs2.Gs2SkillTree.Request.ReleaseByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPropertyId("property-0001")
        .WithNodeModelNames(new string[] {
            "node-0001",
        })
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.releaseByUserId(
        new Gs2SkillTree.ReleaseByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames([
                "node-0001",
            ])
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.release_by_user_id(
        skill_tree.ReleaseByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_property_id('property-0001')
            .with_node_model_names([
                'node-0001',
            ])
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.release_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

client = gs2('skill_tree')

api_result_handler = client.release_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\MarkRestrainRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->markRestrain(
        (new MarkRestrainRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withPropertyId("property-0001")
            ->withNodeModelNames([
                "node-0001",
            ])
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.MarkRestrainRequest;
import io.gs2.skillTree.result.MarkRestrainResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    MarkRestrainResult result = client.markRestrain(
        new MarkRestrainRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.MarkRestrainResult> asyncResult = null;
yield return client.MarkRestrain(
    new Gs2.Gs2SkillTree.Request.MarkRestrainRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithPropertyId("property-0001")
        .WithNodeModelNames(new string[] {
            "node-0001",
        }),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.markRestrain(
        new Gs2SkillTree.MarkRestrainRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames([
                "node-0001",
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.mark_restrain(
        skill_tree.MarkRestrainRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_property_id('property-0001')
            .with_node_model_names([
                'node-0001',
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.mark_restrain({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.mark_restrain_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\MarkRestrainByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->markRestrainByUserId(
        (new MarkRestrainByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPropertyId("property-0001")
            ->withNodeModelNames([
                "node-0001",
            ])
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.MarkRestrainByUserIdRequest;
import io.gs2.skillTree.result.MarkRestrainByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    MarkRestrainByUserIdResult result = client.markRestrainByUserId(
        new MarkRestrainByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.MarkRestrainByUserIdResult> asyncResult = null;
yield return client.MarkRestrainByUserId(
    new Gs2.Gs2SkillTree.Request.MarkRestrainByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPropertyId("property-0001")
        .WithNodeModelNames(new string[] {
            "node-0001",
        })
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.markRestrainByUserId(
        new Gs2SkillTree.MarkRestrainByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames([
                "node-0001",
            ])
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.mark_restrain_by_user_id(
        skill_tree.MarkRestrainByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_property_id('property-0001')
            .with_node_model_names([
                'node-0001',
            ])
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.mark_restrain_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.mark_restrain_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\RestrainRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->restrain(
        (new RestrainRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withPropertyId("property-0001")
            ->withNodeModelNames([
                "node-0001",
            ])
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.RestrainRequest;
import io.gs2.skillTree.result.RestrainResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    RestrainResult result = client.restrain(
        new RestrainRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
            .withConfig(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.RestrainResult> asyncResult = null;
yield return client.Restrain(
    new Gs2.Gs2SkillTree.Request.RestrainRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithPropertyId("property-0001")
        .WithNodeModelNames(new string[] {
            "node-0001",
        })
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.restrain(
        new Gs2SkillTree.RestrainRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames([
                "node-0001",
            ])
            .withConfig(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.restrain(
        skill_tree.RestrainRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_property_id('property-0001')
            .with_node_model_names([
                'node-0001',
            ])
            .with_config(None)
    )
    item = result.item
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.restrain({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

client = gs2('skill_tree')

api_result_handler = client.restrain_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\RestrainByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->restrainByUserId(
        (new RestrainByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPropertyId("property-0001")
            ->withNodeModelNames([
                "node-0001",
            ])
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.RestrainByUserIdRequest;
import io.gs2.skillTree.result.RestrainByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    RestrainByUserIdResult result = client.restrainByUserId(
        new RestrainByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.RestrainByUserIdResult> asyncResult = null;
yield return client.RestrainByUserId(
    new Gs2.Gs2SkillTree.Request.RestrainByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPropertyId("property-0001")
        .WithNodeModelNames(new string[] {
            "node-0001",
        })
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.restrainByUserId(
        new Gs2SkillTree.RestrainByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withNodeModelNames([
                "node-0001",
            ])
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.restrain_by_user_id(
        skill_tree.RestrainByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_property_id('property-0001')
            .with_node_model_names([
                'node-0001',
            ])
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.restrain_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

client = gs2('skill_tree')

api_result_handler = client.restrain_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    nodeModelNames={
        "node-0001"
    },
    config=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DescribeStatusesRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->describeStatuses(
        (new DescribeStatusesRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DescribeStatusesRequest;
import io.gs2.skillTree.result.DescribeStatusesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DescribeStatusesResult result = client.describeStatuses(
        new DescribeStatusesRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Status> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeStatusesResult> asyncResult = null;
yield return client.DescribeStatuses(
    new Gs2.Gs2SkillTree.Request.DescribeStatusesRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.describeStatuses(
        new Gs2SkillTree.DescribeStatusesRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.describe_statuses(
        skill_tree.DescribeStatusesRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.describe_statuses({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('skill_tree')

api_result_handler = client.describe_statuses_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DescribeStatusesByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->describeStatusesByUserId(
        (new DescribeStatusesByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DescribeStatusesByUserIdRequest;
import io.gs2.skillTree.result.DescribeStatusesByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DescribeStatusesByUserIdResult result = client.describeStatusesByUserId(
        new DescribeStatusesByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<Status> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeStatusesByUserIdResult> asyncResult = null;
yield return client.DescribeStatusesByUserId(
    new Gs2.Gs2SkillTree.Request.DescribeStatusesByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.describeStatusesByUserId(
        new Gs2SkillTree.DescribeStatusesByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.describe_statuses_by_user_id(
        skill_tree.DescribeStatusesByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.describe_statuses_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('skill_tree')

api_result_handler = client.describe_statuses_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetStatusRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getStatus(
        (new GetStatusRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withPropertyId("property-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetStatusRequest;
import io.gs2.skillTree.result.GetStatusResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetStatusResult result = client.getStatus(
        new GetStatusRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetStatusResult> asyncResult = null;
yield return client.GetStatus(
    new Gs2.Gs2SkillTree.Request.GetStatusRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithPropertyId("property-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getStatus(
        new Gs2SkillTree.GetStatusRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_status(
        skill_tree.GetStatusRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_property_id('property-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_status({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.get_status_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetStatusByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getStatusByUserId(
        (new GetStatusByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetStatusByUserIdRequest;
import io.gs2.skillTree.result.GetStatusByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetStatusByUserIdResult result = client.getStatusByUserId(
        new GetStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetStatusByUserIdResult> asyncResult = null;
yield return client.GetStatusByUserId(
    new Gs2.Gs2SkillTree.Request.GetStatusByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getStatusByUserId(
        new Gs2SkillTree.GetStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_status_by_user_id(
        skill_tree.GetStatusByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_status_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.get_status_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\ResetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->reset(
        (new ResetRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withPropertyId("property-0001")
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.ResetRequest;
import io.gs2.skillTree.result.ResetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    ResetResult result = client.reset(
        new ResetRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withConfig(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ResetResult> asyncResult = null;
yield return client.Reset(
    new Gs2.Gs2SkillTree.Request.ResetRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithPropertyId("property-0001")
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.reset(
        new Gs2SkillTree.ResetRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withConfig(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.reset(
        skill_tree.ResetRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_property_id('property-0001')
            .with_config(None)
    )
    item = result.item
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.reset({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    config=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

client = gs2('skill_tree')

api_result_handler = client.reset_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    config=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\ResetByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->resetByUserId(
        (new ResetByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withPropertyId("property-0001")
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.ResetByUserIdRequest;
import io.gs2.skillTree.result.ResetByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    ResetByUserIdResult result = client.resetByUserId(
        new ResetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ResetByUserIdResult> asyncResult = null;
yield return client.ResetByUserId(
    new Gs2.Gs2SkillTree.Request.ResetByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithPropertyId("property-0001")
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.resetByUserId(
        new Gs2SkillTree.ResetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.reset_by_user_id(
        skill_tree.ResetByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_property_id('property-0001')
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.reset_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    config=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

client = gs2('skill_tree')

api_result_handler = client.reset_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    propertyId="property-0001",
    config=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DescribeNodeModelsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->describeNodeModels(
        (new DescribeNodeModelsRequest())
            ->withNamespaceName("namespace-0001")
    );
    $items = $result->getItems();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DescribeNodeModelsRequest;
import io.gs2.skillTree.result.DescribeNodeModelsResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DescribeNodeModelsResult result = client.describeNodeModels(
        new DescribeNodeModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<NodeModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeNodeModelsResult> asyncResult = null;
yield return client.DescribeNodeModels(
    new Gs2.Gs2SkillTree.Request.DescribeNodeModelsRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.describeNodeModels(
        new Gs2SkillTree.DescribeNodeModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.describe_node_models(
        skill_tree.DescribeNodeModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.describe_node_models({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;

client = gs2('skill_tree')

api_result_handler = client.describe_node_models_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetNodeModelRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getNodeModel(
        (new GetNodeModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withNodeModelName("status-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetNodeModelRequest;
import io.gs2.skillTree.result.GetNodeModelResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetNodeModelResult result = client.getNodeModel(
        new GetNodeModelRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("status-0001")
    );
    NodeModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNodeModelResult> asyncResult = null;
yield return client.GetNodeModel(
    new Gs2.Gs2SkillTree.Request.GetNodeModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithNodeModelName("status-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getNodeModel(
        new Gs2SkillTree.GetNodeModelRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("status-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_node_model(
        skill_tree.GetNodeModelRequest()
            .with_namespace_name('namespace-0001')
            .with_node_model_name('status-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_node_model({
    namespaceName="namespace-0001",
    nodeModelName="status-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.get_node_model_async({
    namespaceName="namespace-0001",
    nodeModelName="status-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\ExportMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->exportMaster(
        (new ExportMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.ExportMasterRequest;
import io.gs2.skillTree.result.ExportMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    ExportMasterResult result = client.exportMaster(
        new ExportMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ExportMasterResult> asyncResult = null;
yield return client.ExportMaster(
    new Gs2.Gs2SkillTree.Request.ExportMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.exportMaster(
        new Gs2SkillTree.ExportMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.export_master(
        skill_tree.ExportMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.export_master({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.export_master_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetCurrentTreeMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getCurrentTreeMaster(
        (new GetCurrentTreeMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetCurrentTreeMasterRequest;
import io.gs2.skillTree.result.GetCurrentTreeMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetCurrentTreeMasterResult result = client.getCurrentTreeMaster(
        new GetCurrentTreeMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetCurrentTreeMasterResult> asyncResult = null;
yield return client.GetCurrentTreeMaster(
    new Gs2.Gs2SkillTree.Request.GetCurrentTreeMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getCurrentTreeMaster(
        new Gs2SkillTree.GetCurrentTreeMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_current_tree_master(
        skill_tree.GetCurrentTreeMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_current_tree_master({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.get_current_tree_master_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\PreUpdateCurrentTreeMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentTreeMaster(
        (new PreUpdateCurrentTreeMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.PreUpdateCurrentTreeMasterRequest;
import io.gs2.skillTree.result.PreUpdateCurrentTreeMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    PreUpdateCurrentTreeMasterResult result = client.preUpdateCurrentTreeMaster(
        new PreUpdateCurrentTreeMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    String uploadToken = result.getUploadToken();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.PreUpdateCurrentTreeMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentTreeMaster(
    new Gs2.Gs2SkillTree.Request.PreUpdateCurrentTreeMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.preUpdateCurrentTreeMaster(
        new Gs2SkillTree.PreUpdateCurrentTreeMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    const uploadToken = result.getUploadToken();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.pre_update_current_tree_master(
        skill_tree.PreUpdateCurrentTreeMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.pre_update_current_tree_master({
    namespaceName="namespace-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

client = gs2('skill_tree')

api_result_handler = client.pre_update_current_tree_master_async({
    namespaceName="namespace-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\UpdateCurrentTreeMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->updateCurrentTreeMaster(
        (new UpdateCurrentTreeMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": []}, {\"name\": \"node-0002\", \"metadata\": \"NODE-0002\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 15}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0001\"]}, {\"name\": \"node-0003\", \"metadata\": \"NODE-0003\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}")
            ->withUploadToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.UpdateCurrentTreeMasterRequest;
import io.gs2.skillTree.result.UpdateCurrentTreeMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    UpdateCurrentTreeMasterResult result = client.updateCurrentTreeMaster(
        new UpdateCurrentTreeMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": []}, {\"name\": \"node-0002\", \"metadata\": \"NODE-0002\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 15}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0001\"]}, {\"name\": \"node-0003\", \"metadata\": \"NODE-0003\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}")
            .withUploadToken(null)
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateCurrentTreeMasterResult> asyncResult = null;
yield return client.UpdateCurrentTreeMaster(
    new Gs2.Gs2SkillTree.Request.UpdateCurrentTreeMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": []}, {\"name\": \"node-0002\", \"metadata\": \"NODE-0002\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 15}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0001\"]}, {\"name\": \"node-0003\", \"metadata\": \"NODE-0003\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}")
        .WithUploadToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.updateCurrentTreeMaster(
        new Gs2SkillTree.UpdateCurrentTreeMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": []}, {\"name\": \"node-0002\", \"metadata\": \"NODE-0002\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 15}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0001\"]}, {\"name\": \"node-0003\", \"metadata\": \"NODE-0003\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.update_current_tree_master(
        skill_tree.UpdateCurrentTreeMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{"version": "2023-09-06", "nodeModels": [{"name": "node-0001", "metadata": "NODE-0001", "releaseConsumeActions": [{"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}"}], "restrainReturnRate": 0.5, "premiseNodeNames": []}, {"name": "node-0002", "metadata": "NODE-0002", "releaseConsumeActions": [{"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 15}"}], "restrainReturnRate": 0.5, "premiseNodeNames": ["node-0001"]}, {"name": "node-0003", "metadata": "NODE-0003", "releaseConsumeActions": [{"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}"}, {"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}"}], "restrainReturnRate": 0.5, "premiseNodeNames": ["node-0002"]}]}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.update_current_tree_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": []}, {\"name\": \"node-0002\", \"metadata\": \"NODE-0002\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 15}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0001\"]}, {\"name\": \"node-0003\", \"metadata\": \"NODE-0003\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}",
    uploadToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.update_current_tree_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": []}, {\"name\": \"node-0002\", \"metadata\": \"NODE-0002\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 15}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0001\"]}, {\"name\": \"node-0003\", \"metadata\": \"NODE-0003\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}",
    uploadToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\UpdateCurrentTreeMasterFromGitHubRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->updateCurrentTreeMasterFromGitHub(
        (new UpdateCurrentTreeMasterFromGitHubRequest())
            ->withNamespaceName("namespace-0001")
            ->withCheckoutSetting((new GitHubCheckoutSetting())
                ->withApiKeyId("apiKeyId-0001")
                ->withRepositoryName("gs2io/master-data")
                ->withSourcePath("path/to/file.json")
                ->withReferenceType("branch")
                ->withBranchName("develop")
            )
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.UpdateCurrentTreeMasterFromGitHubRequest;
import io.gs2.skillTree.result.UpdateCurrentTreeMasterFromGitHubResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    UpdateCurrentTreeMasterFromGitHubResult result = client.updateCurrentTreeMasterFromGitHub(
        new UpdateCurrentTreeMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateCurrentTreeMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentTreeMasterFromGitHub(
    new Gs2.Gs2SkillTree.Request.UpdateCurrentTreeMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2SkillTree.Model.GitHubCheckoutSetting()
            .WithApiKeyId("apiKeyId-0001")
            .WithRepositoryName("gs2io/master-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        ),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.updateCurrentTreeMasterFromGitHub(
        new Gs2SkillTree.UpdateCurrentTreeMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2SkillTree.model.GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.update_current_tree_master_from_git_hub(
        skill_tree.UpdateCurrentTreeMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(skill_tree.GitHubCheckoutSetting()
                .with_api_key_id('apiKeyId-0001')
                .with_repository_name('gs2io/master-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.update_current_tree_master_from_git_hub({
    namespaceName="namespace-0001",
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/master-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.update_current_tree_master_from_git_hub_async({
    namespaceName="namespace-0001",
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/master-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DescribeNodeModelMastersRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->describeNodeModelMasters(
        (new DescribeNodeModelMastersRequest())
            ->withNamespaceName("namespace-0001")
            ->withNamePrefix(null)
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DescribeNodeModelMastersRequest;
import io.gs2.skillTree.result.DescribeNodeModelMastersResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DescribeNodeModelMastersResult result = client.describeNodeModelMasters(
        new DescribeNodeModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    List<NodeModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeNodeModelMastersResult> asyncResult = null;
yield return client.DescribeNodeModelMasters(
    new Gs2.Gs2SkillTree.Request.DescribeNodeModelMastersRequest()
        .WithNamespaceName("namespace-0001")
        .WithNamePrefix(null)
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.describeNodeModelMasters(
        new Gs2SkillTree.DescribeNodeModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.describe_node_model_masters(
        skill_tree.DescribeNodeModelMastersRequest()
            .with_namespace_name('namespace-0001')
            .with_name_prefix(None)
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.describe_node_model_masters({
    namespaceName="namespace-0001",
    namePrefix=nil,
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('skill_tree')

api_result_handler = client.describe_node_model_masters_async({
    namespaceName="namespace-0001",
    namePrefix=nil,
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\CreateNodeModelMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->createNodeModelMaster(
        (new CreateNodeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("node-0001")
            ->withDescription(null)
            ->withMetadata("NODE-0001")
            ->withReleaseVerifyActions(null)
            ->withReleaseConsumeActions([
                (new \Gs2\SkillTree\Model\ConsumeAction())
                    ->withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
            ])
            ->withRestrainReturnRate(1.0)
            ->withPremiseNodeNames([])
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.CreateNodeModelMasterRequest;
import io.gs2.skillTree.result.CreateNodeModelMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    CreateNodeModelMasterResult result = client.createNodeModelMaster(
        new CreateNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("node-0001")
            .withDescription(null)
            .withMetadata("NODE-0001")
            .withReleaseVerifyActions(null)
            .withReleaseConsumeActions(Arrays.asList(
                new io.gs2.skillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 10}")
            ))
            .withRestrainReturnRate(1.0f)
            .withPremiseNodeNames(new ArrayList<String>())
    );
    NodeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CreateNodeModelMasterResult> asyncResult = null;
yield return client.CreateNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.CreateNodeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("node-0001")
        .WithDescription(null)
        .WithMetadata("NODE-0001")
        .WithReleaseVerifyActions(null)
        .WithReleaseConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Inventory:ConsumeItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
        })
        .WithRestrainReturnRate(1.0f)
        .WithPremiseNodeNames(new string[] {}),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.createNodeModelMaster(
        new Gs2SkillTree.CreateNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("node-0001")
            .withDescription(null)
            .withMetadata("NODE-0001")
            .withReleaseVerifyActions(null)
            .withReleaseConsumeActions([
                new Gs2SkillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
            ])
            .withRestrainReturnRate(1.0)
            .withPremiseNodeNames([])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.create_node_model_master(
        skill_tree.CreateNodeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('node-0001')
            .with_description(None)
            .with_metadata('NODE-0001')
            .with_release_verify_actions(None)
            .with_release_consume_actions([
                skill_tree.ConsumeAction()
                    .with_action('Gs2Inventory:ConsumeItemSetByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "potion", "userId": "#{userId}", "consumeCount": 10}'),
            ])
            .with_restrain_return_rate(1.0)
            .with_premise_node_names([])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.create_node_model_master({
    namespaceName="namespace-0001",
    name="node-0001",
    description=nil,
    metadata="NODE-0001",
    releaseVerifyActions=nil,
    releaseConsumeActions={
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
        }
    },
    restrainReturnRate=1.0,
    premiseNodeNames={},
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.create_node_model_master_async({
    namespaceName="namespace-0001",
    name="node-0001",
    description=nil,
    metadata="NODE-0001",
    releaseVerifyActions=nil,
    releaseConsumeActions={
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
        }
    },
    restrainReturnRate=1.0,
    premiseNodeNames={},
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\GetNodeModelMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->getNodeModelMaster(
        (new GetNodeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withNodeModelName("node-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.GetNodeModelMasterRequest;
import io.gs2.skillTree.result.GetNodeModelMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    GetNodeModelMasterResult result = client.getNodeModelMaster(
        new GetNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("node-0001")
    );
    NodeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNodeModelMasterResult> asyncResult = null;
yield return client.GetNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.GetNodeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithNodeModelName("node-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.getNodeModelMaster(
        new Gs2SkillTree.GetNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("node-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.get_node_model_master(
        skill_tree.GetNodeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_node_model_name('node-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.get_node_model_master({
    namespaceName="namespace-0001",
    nodeModelName="node-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.get_node_model_master_async({
    namespaceName="namespace-0001",
    nodeModelName="node-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\UpdateNodeModelMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->updateNodeModelMaster(
        (new UpdateNodeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withNodeModelName("node-0001")
            ->withDescription("description1")
            ->withMetadata("NODE-0001")
            ->withReleaseVerifyActions(null)
            ->withReleaseConsumeActions([
                (new \Gs2\SkillTree\Model\ConsumeAction())
                    ->withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 20}"),
            ])
            ->withRestrainReturnRate(0.9)
            ->withPremiseNodeNames(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.UpdateNodeModelMasterRequest;
import io.gs2.skillTree.result.UpdateNodeModelMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    UpdateNodeModelMasterResult result = client.updateNodeModelMaster(
        new UpdateNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("node-0001")
            .withDescription("description1")
            .withMetadata("NODE-0001")
            .withReleaseVerifyActions(null)
            .withReleaseConsumeActions(Arrays.asList(
                new io.gs2.skillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 20}")
            ))
            .withRestrainReturnRate(0.9f)
            .withPremiseNodeNames(null)
    );
    NodeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateNodeModelMasterResult> asyncResult = null;
yield return client.UpdateNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.UpdateNodeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithNodeModelName("node-0001")
        .WithDescription("description1")
        .WithMetadata("NODE-0001")
        .WithReleaseVerifyActions(null)
        .WithReleaseConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Inventory:ConsumeItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 20}"),
        })
        .WithRestrainReturnRate(0.9f)
        .WithPremiseNodeNames(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.updateNodeModelMaster(
        new Gs2SkillTree.UpdateNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("node-0001")
            .withDescription("description1")
            .withMetadata("NODE-0001")
            .withReleaseVerifyActions(null)
            .withReleaseConsumeActions([
                new Gs2SkillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 20}"),
            ])
            .withRestrainReturnRate(0.9)
            .withPremiseNodeNames(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.update_node_model_master(
        skill_tree.UpdateNodeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_node_model_name('node-0001')
            .with_description('description1')
            .with_metadata('NODE-0001')
            .with_release_verify_actions(None)
            .with_release_consume_actions([
                skill_tree.ConsumeAction()
                    .with_action('Gs2Inventory:ConsumeItemSetByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "potion", "userId": "#{userId}", "consumeCount": 20}'),
            ])
            .with_restrain_return_rate(0.9)
            .with_premise_node_names(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.update_node_model_master({
    namespaceName="namespace-0001",
    nodeModelName="node-0001",
    description="description1",
    metadata="NODE-0001",
    releaseVerifyActions=nil,
    releaseConsumeActions={
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 20}",
        }
    },
    restrainReturnRate=0.9,
    premiseNodeNames=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.update_node_model_master_async({
    namespaceName="namespace-0001",
    nodeModelName="node-0001",
    description="description1",
    metadata="NODE-0001",
    releaseVerifyActions=nil,
    releaseConsumeActions={
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 20}",
        }
    },
    restrainReturnRate=0.9,
    premiseNodeNames=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SkillTree\Gs2SkillTreeRestClient;
use Gs2\SkillTree\Request\DeleteNodeModelMasterRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2SkillTreeRestClient(
    $session
);

try {
    $result = $client->deleteNodeModelMaster(
        (new DeleteNodeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withNodeModelName("node-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.skillTree.rest.Gs2SkillTreeRestClient;
import io.gs2.skillTree.request.DeleteNodeModelMasterRequest;
import io.gs2.skillTree.result.DeleteNodeModelMasterResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SkillTreeRestClient client = new Gs2SkillTreeRestClient(session);

try {
    DeleteNodeModelMasterResult result = client.deleteNodeModelMaster(
        new DeleteNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("node-0001")
    );
    NodeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DeleteNodeModelMasterResult> asyncResult = null;
yield return client.DeleteNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.DeleteNodeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithNodeModelName("node-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2SkillTree from '@/gs2/skillTree';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2SkillTree.Gs2SkillTreeRestClient(session);

try {
    const result = await client.deleteNodeModelMaster(
        new Gs2SkillTree.DeleteNodeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withNodeModelName("node-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import skill_tree

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = skill_tree.Gs2SkillTreeRestClient(session)

try:
    result = client.delete_node_model_master(
        skill_tree.DeleteNodeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_node_model_name('node-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skill_tree')

api_result = client.delete_node_model_master({
    namespaceName="namespace-0001",
    nodeModelName="node-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;

client = gs2('skill_tree')

api_result_handler = client.delete_node_model_master_async({
    namespaceName="namespace-0001",
    nodeModelName="node-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['errorMessage'])
end

result = api_result.result
item = result.item;