API Reference of GS2-SkillTree SDK

Model

Namespace

Namespace is a mechanism that allows multiple uses of the same service for different purposes within a single project. Basically, GS2 services have a layer called namespace, and different namespaces are treated as completely different data spaces, even for the same service.

Therefore, it is necessary to create a namespace before starting to use each service.

	Type	Require	Default	Limitation	Description
namespaceId	string	✓		~ 1024 chars	Namespace GRN
name	string	✓		~ 32 chars	Namespace name
description	string			~ 1024 chars	description of Namespace
transactionSetting	TransactionSetting	✓			Transaction settings
releaseScript	ScriptSetting				Script to run when a node is released
restrainScript	ScriptSetting				Script to run when a node is restrained
logSetting	LogSetting				Log output settings
createdAt	long	✓			Datetime of creation
updatedAt	long	✓			Datetime of last update
revision	long		0	~ 9223372036854775805	Revision

NodeModel

The node model is the entity to be recorded in the skill tree. This section defines what kind of entities can be recorded in the skill tree.

	Type	Require	Default	Limitation	Description
nodeModelId	string	✓		~ 1024 chars	Node Model GRN
name	string	✓		~ 128 chars	Node Model Name
metadata	string			~ 2048 chars	metadata
releaseConsumeActions	List<ConsumeAction>	✓	[]	1 ~ 10 items	List of consume actions required for release
returnAcquireActions	List<AcquireAction>			~ 10 items	List of acquire actions required for return
restrainReturnRate	float	✓	1	~ 1	Return Rate
premiseNodeNames	List<string>			~ 10 items	List of premise node model name

NodeModelMaster

The node model is the entity to be recorded in the skill tree. This section defines what kind of entities can be recorded in the skill tree.

	Type	Require	Default	Limitation	Description
nodeModelId	string	✓		~ 1024 chars	Node Model Master GRN
name	string	✓		~ 128 chars	Node Model Name
description	string			~ 1024 chars	description of Namespace
metadata	string			~ 2048 chars	metadata
releaseConsumeActions	List<ConsumeAction>	✓	[]	1 ~ 10 items	List of consume actions required for release
restrainReturnRate	float	✓	1.0	~ 1.0	Return Rate
premiseNodeNames	List<string>			~ 10 items	List of premise node model name
createdAt	long	✓			Datetime of creation
updatedAt	long	✓			Datetime of last update
revision	long		0	~ 9223372036854775805	Revision

Status

Status of skill tree

	Type	Require	Default	Limitation	Description
statusId	string	✓		~ 1024 chars	Status GRN
userId	string	✓		~ 128 chars	User Id
releasedNodeNames	List<string>		[]	~ 1000 items	List of released node model name
createdAt	long	✓			Datetime of creation
updatedAt	long	✓			Datetime of last update
revision	long		0	~ 9223372036854775805	Revision

CurrentTreeMaster

Currently available master data

GS2 uses JSON format files for master data management. By uploading the file, you can actually reflect the settings on the server.

We provide a master data editor on the management console as a way to create JSON files, but you can also create JSON files using the The service can also be used by creating a tool more appropriate for game management and exporting a JSON file in the appropriate format.

Please refer to the documentation for the format of the JSON file.

	Type	Condition	Require	Default	Limitation	Description
namespaceId	string		✓		~ 1024 chars	Namespace GRN
settings	string		✓		~ 5242880 chars	Master data

Config

	Type	Condition	Require	Default	Limitation	Description
key	string		✓		~ 64 chars	Name
value	string				~ 51200 chars	Value

ConsumeAction

	Type	Condition	Require	Default	Limitation	Description
action	enum []		✓		~ 128 chars	Types of actions to be performed in the stamp task
request	string		✓		~ 1048576 chars	JSON of the obtain request

AcquireAction

	Type	Condition	Require	Default	Limitation	Description
action	enum []		✓		~ 128 chars	Types of actions to be performed in the stamp sheet
request	string		✓		~ 1048576 chars	JSON of request

GitHubCheckoutSetting

	Type	Condition	Require	Limitation	Description
apiKeyId	string		✓	~ 1024 chars	GitHub API key GRN
repositoryName	string		✓	~ 1024 chars	Repository Name
sourcePath	string		✓	~ 1024 chars	Source code file path
referenceType	enum [‘commit_hash’, ‘branch’, ’tag’]		✓	~ 128 chars	Source of code
commitHash	string	{referenceType} == “commit_hash”	✓	~ 1024 chars	Commit hash
branchName	string	{referenceType} == “branch”	✓	~ 1024 chars	Branch Name
tagName	string	{referenceType} == “tag”	✓	~ 1024 chars	Tag Name

ScriptSetting

	Type	Condition	Require	Default	Limitation	Description
triggerScriptId	string				~ 1024 chars	Script GRN
doneTriggerTargetType	enum [’none’, ‘gs2_script’, ‘aws’]		✓	“none”	~ 128 chars	Notification of Completion
doneTriggerScriptId	string	{doneTriggerTargetType} == “gs2_script”			~ 1024 chars	Script GRN
doneTriggerQueueNamespaceId	string	{doneTriggerTargetType} == “gs2_script”			~ 1024 chars	Namespace GRN

TransactionSetting

	Type	Condition	Require	Default	Limitation	Description
enableAutoRun	bool		✓	false		Automatically run issued stamp sheets on the server side, or
distributorNamespaceId	string	{enableAutoRun}	✓		~ 1024 chars	GS2-Distributor namespace used for stamp sheet execution
keyId	string	!{enableAutoRun}	✓		~ 1024 chars	GS2-Key encryption key used to sign the stamp sheet
queueNamespaceId	string				~ 1024 chars	Namespace in GS2-JobQueue used to run the stamp sheet

LogSetting

	Type	Condition	Require	Default	Limitation	Description
loggingNamespaceId	string		✓		~ 1024 chars	Namespace GRN

Methods

describeNamespaces

Get list of namespaces

Request

	Type	Condition	Require	Default	Limitation	Description
pageToken	string				~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int		✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<Namespace>	List of Namespace
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &skill_tree.DescribeNamespacesRequest {
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
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\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNamespaces(
        (new DescribeNamespacesRequest())
            ->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()
            .withPageToken(null)
            .withLimit(null)
    );
    List<Namespace> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.DescribeNamespacesRequest;
using Gs2.Gs2SkillTree.Result.DescribeNamespacesResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2SkillTree.Request.DescribeNamespacesRequest()
        .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()
            .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_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('skillTree')

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

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

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

createNamespace

Create a new namespace

Request

	Type	Require	Limitation	Description
name	string	✓	~ 32 chars	Namespace name
description	string		~ 1024 chars	description of Namespace
transactionSetting	TransactionSetting	✓		Transaction settings
releaseScript	ScriptSetting			Script to run when a node is released
restrainScript	ScriptSetting			Script to run when a node is restrained
logSetting	LogSetting			Log output settings

Result

	Type	Description
item	Namespace	Namespace created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &skill_tree.CreateNamespaceRequest {
        Name: pointy.String("namespace1"),
        Description: nil,
        TransactionSetting: &skillTree.TransactionSetting{
            EnableAutoRun: pointy.Bool(false),
            QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
            KeyId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"),
        },
        ReleaseScript: nil,
        RestrainScript: nil,
        LogSetting: &skillTree.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
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\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName(self::namespace1)
            ->withDescription(null)
            ->withTransactionSetting((new \Gs2\SkillTree\Model\TransactionSetting())
                ->withEnableAutoRun(False)
                ->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
                ->withKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:\namespace1:key:key-0001"))
            ->withReleaseScript(null)
            ->withRestrainScript(null)
            ->withLogSetting((new \Gs2\SkillTree\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
    );
    $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("namespace1")
            .withDescription(null)
            .withTransactionSetting(new io.gs2.skillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
                .withKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new io.gs2.skillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.CreateNamespaceRequest;
using Gs2.Gs2SkillTree.Result.CreateNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2SkillTree.Request.CreateNamespaceRequest()
        .WithName("namespace1")
        .WithDescription(null)
        .WithTransactionSetting(new Gs2.Gs2SkillTree.Model.TransactionSetting()
            .WithEnableAutoRun(false)
            .WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
            .WithKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"))
        .WithReleaseScript(null)
        .WithRestrainScript(null)
        .WithLogSetting(new Gs2.Gs2SkillTree.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1")),
    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("namespace1")
            .withDescription(null)
            .withTransactionSetting(new Gs2SkillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
                .withKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new Gs2SkillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    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(self.hash1)
            .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_key_id('grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-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:namespace1'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

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

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

result = api_result.result
item = result.item;

getNamespaceStatus

Get namespace status

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name

Result

	Type	Description
status	string

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &skill_tree.GetNamespaceStatusRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
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\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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("namespace1")
    );
    String status = result.getStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.GetNamespaceStatusRequest;
using Gs2.Gs2SkillTree.Result.GetNamespaceStatusResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2SkillTree.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace1"),
    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("namespace1")
    );
    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(self.hash1)
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.get_namespace_status({
    namespaceName='namespace1',
})

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

result = api_result.result
status = result.status;

getNamespace

Get namespace

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name

Result

	Type	Description
item	Namespace	Namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &skill_tree.GetNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
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\GetNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.GetNamespaceRequest;
using Gs2.Gs2SkillTree.Result.GetNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2SkillTree.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace1"),
    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("namespace1")
    );
    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(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.get_namespace({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

updateNamespace

Update namespace

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
description	string		~ 1024 chars	description of Namespace
transactionSetting	TransactionSetting	✓		Transaction settings
releaseScript	ScriptSetting			Script to run when a node is released
restrainScript	ScriptSetting			Script to run when a node is restrained
logSetting	LogSetting			Log output settings

Result

	Type	Description
item	Namespace	Updated namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &skill_tree.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
        Description: pointy.String("description1"),
        TransactionSetting: &skillTree.TransactionSetting{
            EnableAutoRun: pointy.Bool(false),
            QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
            KeyId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"),
        },
        ReleaseScript: nil,
        RestrainScript: nil,
        LogSetting: &skillTree.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName(self::namespace1)
            ->withDescription("description1")
            ->withTransactionSetting((new \Gs2\SkillTree\Model\TransactionSetting())
                ->withEnableAutoRun(False)
                ->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
                ->withKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:\namespace1:key:key-0001"))
            ->withReleaseScript(null)
            ->withRestrainScript(null)
            ->withLogSetting((new \Gs2\SkillTree\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
    );
    $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("namespace1")
            .withDescription("description1")
            .withTransactionSetting(new io.gs2.skillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
                .withKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new io.gs2.skillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.UpdateNamespaceRequest;
using Gs2.Gs2SkillTree.Result.UpdateNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2SkillTree.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace1")
        .WithDescription("description1")
        .WithTransactionSetting(new Gs2.Gs2SkillTree.Model.TransactionSetting()
            .WithEnableAutoRun(false)
            .WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
            .WithKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"))
        .WithReleaseScript(null)
        .WithRestrainScript(null)
        .WithLogSetting(new Gs2.Gs2SkillTree.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1")),
    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("namespace1")
            .withDescription("description1")
            .withTransactionSetting(new Gs2SkillTree.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
                .withKeyId("grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-0001"))
            .withReleaseScript(null)
            .withRestrainScript(null)
            .withLogSetting(new Gs2SkillTree.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    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(self.hash1)
            .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_key_id('grn:gs2:ap-northeast-1:YourOwnerId:key:namespace1:key:key-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:namespace1'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

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

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

result = api_result.result
item = result.item;

deleteNamespace

Delete namespace

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name

Result

	Type	Description
item	Namespace	Deleted namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &skill_tree.DeleteNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.DeleteNamespaceRequest;
using Gs2.Gs2SkillTree.Result.DeleteNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2SkillTree.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace1"),
    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("namespace1")
    );
    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(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.delete_namespace({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

dumpUserDataByUserId

Get dump data of the data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.DumpUserDataByUserId(
    &skill_tree.DumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->dumpUserDataByUserId(
        (new DumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
    );
} 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")
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.DumpUserDataByUserIdRequest;
using Gs2.Gs2SkillTree.Result.DumpUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DumpUserDataByUserIdResult> asyncResult = null;
yield return client.DumpUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.DumpUserDataByUserIdRequest()
        .WithUserId("user-0001"),
    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")
    );
} 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')
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.dump_user_data_by_user_id({
    userId='user-0001',
})

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

result = api_result.result

checkDumpUserDataByUserId

Check if the dump of the data associated with the specified user ID is complete

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id

Result

	Type	Description
url	string	URL of output data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
    &skill_tree.CheckDumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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\CheckDumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkDumpUserDataByUserId(
        (new CheckDumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
    );
    $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")
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.CheckDumpUserDataByUserIdRequest;
using Gs2.Gs2SkillTree.Result.CheckDumpUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CheckDumpUserDataByUserIdResult> asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.CheckDumpUserDataByUserIdRequest()
        .WithUserId("user-0001"),
    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")
    );
    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')
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.check_dump_user_data_by_user_id({
    userId='user-0001',
})

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

result = api_result.result
url = result.url;

cleanUserDataByUserId

Get clean data of the data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.CleanUserDataByUserId(
    &skill_tree.CleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->cleanUserDataByUserId(
        (new CleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
    );
} 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")
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.CleanUserDataByUserIdRequest;
using Gs2.Gs2SkillTree.Result.CleanUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CleanUserDataByUserIdResult> asyncResult = null;
yield return client.CleanUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.CleanUserDataByUserIdRequest()
        .WithUserId("user-0001"),
    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")
    );
} 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')
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.clean_user_data_by_user_id({
    userId='user-0001',
})

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

result = api_result.result

checkCleanUserDataByUserId

Check if the clean of the data associated with the specified user ID is complete

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
    &skill_tree.CheckCleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkCleanUserDataByUserId(
        (new CheckCleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
    );
} 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")
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.CheckCleanUserDataByUserIdRequest;
using Gs2.Gs2SkillTree.Result.CheckCleanUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CheckCleanUserDataByUserIdResult> asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.CheckCleanUserDataByUserIdRequest()
        .WithUserId("user-0001"),
    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")
    );
} 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')
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.check_clean_user_data_by_user_id({
    userId='user-0001',
})

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

result = api_result.result

prepareImportUserDataByUserId

Start importing data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id

Result

	Type	Description
uploadToken	string	Token used to reflect results after upload
uploadUrl	string	URL used to upload user data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
    &skill_tree.PrepareImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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\PrepareImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareImportUserDataByUserId(
        (new PrepareImportUserDataByUserIdRequest())
            ->withUserId("user-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.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")
    );
    String uploadToken = result.getUploadToken();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.PrepareImportUserDataByUserIdRequest;
using Gs2.Gs2SkillTree.Result.PrepareImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.PrepareImportUserDataByUserIdResult> asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
    new Gs2.Gs2SkillTree.Request.PrepareImportUserDataByUserIdRequest()
        .WithUserId("user-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.prepareImportUserDataByUserId(
        new Gs2SkillTree.PrepareImportUserDataByUserIdRequest()
            .withUserId("user-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.prepare_import_user_data_by_user_id(
        skill_tree.PrepareImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.prepare_import_user_data_by_user_id({
    userId='user-0001',
})

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

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

importUserDataByUserId

Start importing data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
uploadToken	string		✓		~ 1024 chars	Token received in preparation for upload

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.ImportUserDataByUserId(
    &skill_tree.ImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
    }
)
if err != nil {
    panic("error occurred")
}

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->importUserDataByUserId(
        (new ImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
    );
} 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")
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.ImportUserDataByUserIdRequest;
using Gs2.Gs2SkillTree.Result.ImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
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"),
    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")
    );
} 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')
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

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

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

result = api_result.result

checkImportUserDataByUserId

Check if the import of the data associated with the specified user ID is complete

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
uploadToken	string		✓		~ 1024 chars	Token received in preparation for upload

Result

	Type	Description
url	string	URL of log data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
    &skill_tree.CheckImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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\CheckImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkImportUserDataByUserId(
        (new CheckImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
    );
    $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")
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.CheckImportUserDataByUserIdRequest;
using Gs2.Gs2SkillTree.Result.CheckImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
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"),
    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")
    );
    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')
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

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

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

result = api_result.result
url = result.url;

describeNodeModels

Get list of status models

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name

Result

	Type	Description
items	List<NodeModel>	List of Node models

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.DescribeNodeModels(
    &skill_tree.DescribeNodeModelsRequest {
        NamespaceName: pointy.String("namespace2"),
    }
)
if err != nil {
    panic("error occurred")
}
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\DescribeNodeModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNodeModels(
        (new DescribeNodeModelsRequest())
            ->withNamespaceName(self::namespace2)
    );
    $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("namespace2")
    );
    List<NodeModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.DescribeNodeModelsRequest;
using Gs2.Gs2SkillTree.Result.DescribeNodeModelsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeNodeModelsResult> asyncResult = null;
yield return client.DescribeNodeModels(
    new Gs2.Gs2SkillTree.Request.DescribeNodeModelsRequest()
        .WithNamespaceName("namespace2"),
    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("namespace2")
    );
    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(self.hash2)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.describe_node_models({
    namespaceName='namespace2',
})

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

result = api_result.result
items = result.items;

getNodeModel

Get an status model

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name
nodeModelName	string		✓		~ 128 chars	Node Model Name

Result

	Type	Description
item	NodeModel	Node model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.GetNodeModel(
    &skill_tree.GetNodeModelRequest {
        NamespaceName: pointy.String("namespace2"),
        NodeModelName: pointy.String("status-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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\GetNodeModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNodeModel(
        (new GetNodeModelRequest())
            ->withNamespaceName(self::namespace2)
            ->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("namespace2")
            .withNodeModelName("status-0001")
    );
    NodeModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.GetNodeModelRequest;
using Gs2.Gs2SkillTree.Result.GetNodeModelResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNodeModelResult> asyncResult = null;
yield return client.GetNodeModel(
    new Gs2.Gs2SkillTree.Request.GetNodeModelRequest()
        .WithNamespaceName("namespace2")
        .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("namespace2")
            .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(self.hash2)
            .with_node_model_name('status-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.get_node_model({
    namespaceName='namespace2',
    nodeModelName='status-0001',
})

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

result = api_result.result
item = result.item;

describeNodeModelMasters

List of status model masters

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<NodeModelMaster>	List of Node Model Masters
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.DescribeNodeModelMasters(
    &skill_tree.DescribeNodeModelMastersRequest {
        NamespaceName: pointy.String("namespace1"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
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\DescribeNodeModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNodeModelMasters(
        (new DescribeNodeModelMastersRequest())
            ->withNamespaceName(self::namespace1)
            ->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("namespace1")
            .withPageToken(null)
            .withLimit(null)
    );
    List<NodeModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.DescribeNodeModelMastersRequest;
using Gs2.Gs2SkillTree.Result.DescribeNodeModelMastersResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DescribeNodeModelMastersResult> asyncResult = null;
yield return client.DescribeNodeModelMasters(
    new Gs2.Gs2SkillTree.Request.DescribeNodeModelMastersRequest()
        .WithNamespaceName("namespace1")
        .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("namespace1")
            .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(self.hash1)
            .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('skillTree')

api_result = client.describe_node_model_masters({
    namespaceName='namespace1',
    pageToken=nil,
    limit=nil,
})

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

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

createNodeModelMaster

Create a new status model master

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
name	string	✓		~ 128 chars	Node Model Name
description	string			~ 1024 chars	description of Namespace
metadata	string			~ 2048 chars	metadata
releaseConsumeActions	List<ConsumeAction>	✓	[]	1 ~ 10 items	List of consume actions required for release
restrainReturnRate	float	✓	1.0	~ 1.0	Return Rate
premiseNodeNames	List<string>			~ 10 items	List of premise node model name

Result

	Type	Description
item	NodeModelMaster	Created status model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.CreateNodeModelMaster(
    &skill_tree.CreateNodeModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        Name: pointy.String("node-0001"),
        Description: nil,
        Metadata: pointy.String("NODE-0001"),
        ReleaseConsumeActions: []skillTree.ConsumeAction{
            skillTree.ConsumeAction{
                Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
                Request: pointy.String("{\"namespaceName\": \"namespace1\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
            },
        },
        RestrainReturnRate: pointy.Float32(1.0),
        PremiseNodeNames: []*string{},
    }
)
if err != nil {
    panic("error occurred")
}
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\CreateNodeModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNodeModelMaster(
        (new CreateNodeModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withName("node-0001")
            ->withDescription(null)
            ->withMetadata("NODE-0001")
            ->withReleaseConsumeActions([    (new \Gs2\SkillTree\Model\ConsumeAction())
                ->withAction("Gs2Inventory:ConsumeItemSetByUserId")
                ->withRequest("{\"namespaceName\": \"\namespace1\", \"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("namespace1")
            .withName("node-0001")
            .withDescription(null)
            .withMetadata("NODE-0001")
            .withReleaseConsumeActions(Arrays.asList(
                new io.gs2.skillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace1\", \"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.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.CreateNodeModelMasterRequest;
using Gs2.Gs2SkillTree.Result.CreateNodeModelMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.CreateNodeModelMasterResult> asyncResult = null;
yield return client.CreateNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.CreateNodeModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithName("node-0001")
        .WithDescription(null)
        .WithMetadata("NODE-0001")
        .WithReleaseConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Inventory:ConsumeItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace1\", \"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("namespace1")
            .withName("node-0001")
            .withDescription(null)
            .withMetadata("NODE-0001")
            .withReleaseConsumeActions([
                new Gs2SkillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace1\", \"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(self.hash1)
            .with_name('node-0001')
            .with_description(None)
            .with_metadata('NODE-0001')
            .with_release_consume_actions([    skill_tree.ConsumeAction()
                .with_action('Gs2Inventory:ConsumeItemSetByUserId')
                .with_request('{"namespaceName": "namespace1", "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('skillTree')

api_result = client.create_node_model_master({
    namespaceName='namespace1',
    name='node-0001',
    description=nil,
    metadata='NODE-0001',
    releaseConsumeActions={
        {
            action='Gs2Inventory:ConsumeItemSetByUserId',
            request='{"namespaceName": "namespace1", "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['message'])
end

result = api_result.result
item = result.item;

getNodeModelMaster

Get Node Model Master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name
nodeModelName	string		✓		~ 128 chars	Node Model Name

Result

	Type	Description
item	NodeModelMaster	Node Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.GetNodeModelMaster(
    &skill_tree.GetNodeModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        NodeModelName: pointy.String("node-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNodeModelMaster(
        (new GetNodeModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->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("namespace1")
            .withNodeModelName("node-0001")
    );
    NodeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.GetNodeModelMasterRequest;
using Gs2.Gs2SkillTree.Result.GetNodeModelMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetNodeModelMasterResult> asyncResult = null;
yield return client.GetNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.GetNodeModelMasterRequest()
        .WithNamespaceName("namespace1")
        .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("namespace1")
            .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(self.hash1)
            .with_node_model_name('node-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.get_node_model_master({
    namespaceName='namespace1',
    nodeModelName='node-0001',
})

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

result = api_result.result
item = result.item;

updateNodeModelMaster

Updated Node Model Master

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
nodeModelName	string	✓		~ 128 chars	Node Model Name
description	string			~ 1024 chars	description of Namespace
metadata	string			~ 2048 chars	metadata
releaseConsumeActions	List<ConsumeAction>	✓	[]	1 ~ 10 items	List of consume actions required for release
restrainReturnRate	float	✓	1.0	~ 1.0	Return Rate
premiseNodeNames	List<string>			~ 10 items	List of premise node model name

Result

	Type	Description
item	NodeModelMaster	Updated status model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.UpdateNodeModelMaster(
    &skill_tree.UpdateNodeModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        NodeModelName: pointy.String("node-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("NODE-0001"),
        ReleaseConsumeActions: []skillTree.ConsumeAction{
            skillTree.ConsumeAction{
                Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
                Request: pointy.String("{\"namespaceName\": \"namespace1\", \"inventoryName\": \"item\", \"itemName\": \"potion\", \"userId\": \"#{userId}\", \"consumeCount\": 20}"),
            },
        },
        RestrainReturnRate: pointy.Float32(0.9),
        PremiseNodeNames: nil,
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNodeModelMaster(
        (new UpdateNodeModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withNodeModelName("node-0001")
            ->withDescription("description1")
            ->withMetadata("NODE-0001")
            ->withReleaseConsumeActions([    (new \Gs2\SkillTree\Model\ConsumeAction())
                ->withAction("Gs2Inventory:ConsumeItemSetByUserId")
                ->withRequest("{\"namespaceName\": \"\namespace1\", \"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("namespace1")
            .withNodeModelName("node-0001")
            .withDescription("description1")
            .withMetadata("NODE-0001")
            .withReleaseConsumeActions(Arrays.asList(
                new io.gs2.skillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace1\", \"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.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.UpdateNodeModelMasterRequest;
using Gs2.Gs2SkillTree.Result.UpdateNodeModelMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateNodeModelMasterResult> asyncResult = null;
yield return client.UpdateNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.UpdateNodeModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithNodeModelName("node-0001")
        .WithDescription("description1")
        .WithMetadata("NODE-0001")
        .WithReleaseConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Inventory:ConsumeItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace1\", \"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("namespace1")
            .withNodeModelName("node-0001")
            .withDescription("description1")
            .withMetadata("NODE-0001")
            .withReleaseConsumeActions([
                new Gs2SkillTree.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace1\", \"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(self.hash1)
            .with_node_model_name('node-0001')
            .with_description('description1')
            .with_metadata('NODE-0001')
            .with_release_consume_actions([    skill_tree.ConsumeAction()
                .with_action('Gs2Inventory:ConsumeItemSetByUserId')
                .with_request('{"namespaceName": "namespace1", "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('skillTree')

api_result = client.update_node_model_master({
    namespaceName='namespace1',
    nodeModelName='node-0001',
    description='description1',
    metadata='NODE-0001',
    releaseConsumeActions={
        {
            action='Gs2Inventory:ConsumeItemSetByUserId',
            request='{"namespaceName": "namespace1", "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['message'])
end

result = api_result.result
item = result.item;

deleteNodeModelMaster

Delete status model master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name
nodeModelName	string		✓		~ 128 chars	Node Model Name

Result

	Type	Description
item	NodeModelMaster	Deleted status model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.DeleteNodeModelMaster(
    &skill_tree.DeleteNodeModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        NodeModelName: pointy.String("node-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNodeModelMaster(
        (new DeleteNodeModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->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("namespace1")
            .withNodeModelName("node-0001")
    );
    NodeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.DeleteNodeModelMasterRequest;
using Gs2.Gs2SkillTree.Result.DeleteNodeModelMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.DeleteNodeModelMasterResult> asyncResult = null;
yield return client.DeleteNodeModelMaster(
    new Gs2.Gs2SkillTree.Request.DeleteNodeModelMasterRequest()
        .WithNamespaceName("namespace1")
        .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("namespace1")
            .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(self.hash1)
            .with_node_model_name('node-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.delete_node_model_master({
    namespaceName='namespace1',
    nodeModelName='node-0001',
})

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

result = api_result.result
item = result.item;

markReleaseByUserId

Mark an status as released by user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
nodeModelNames	List<string>	✓	1 ~ 1000 items	List of node model names

Result

	Type	Description
item	Status	Status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.MarkReleaseByUserId(
    &skill_tree.MarkReleaseByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        NodeModelNames: []*string{
            pointy.String("node-0001"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
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\MarkReleaseByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->markReleaseByUserId(
        (new MarkReleaseByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-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.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("namespace1")
            .withUserId("user-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.MarkReleaseByUserIdRequest;
using Gs2.Gs2SkillTree.Result.MarkReleaseByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.MarkReleaseByUserIdResult> asyncResult = null;
yield return client.MarkReleaseByUserId(
    new Gs2.Gs2SkillTree.Request.MarkReleaseByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-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.markReleaseByUserId(
        new Gs2SkillTree.MarkReleaseByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-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_release_by_user_id(
        skill_tree.MarkReleaseByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_node_model_names([    'node-0001',
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.mark_release_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    nodeModelNames={
        'node-0001'
    },
})

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

result = api_result.result
item = result.item;

release

Release an status by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
nodeModelNames	List<string>	✓		1 ~ 1000 items	List of node model names
config	List<Config>		[]	~ 32 items	Set values to be applied to stamp sheet variables

Result

	Type	Description
item	Status	Status
transactionId	string	Transaction ID of the stamp sheet issued
stampSheet	string	Stamp sheets used to execute the release process
stampSheetEncryptionKeyId	string	Cryptographic key GRN used for stamp sheet signature calculations
autoRunStampSheet	bool?	Is stamp sheet auto-execution enabled?

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.Release(
    &skill_tree.ReleaseRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        NodeModelNames: []*string{
            pointy.String("node-0001"),
        },
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->release(
        (new ReleaseRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withNodeModelNames([    "node-0001",
            ])
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
} 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("namespace1")
            .withAccessToken("$access_token_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();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.ReleaseRequest;
using Gs2.Gs2SkillTree.Result.ReleaseResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ReleaseResult> asyncResult = null;
yield return client.Release(
    new Gs2.Gs2SkillTree.Request.ReleaseRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_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;

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("namespace1")
            .withAccessToken("$access_token_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();
} 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(self.hash1)
            .with_access_token(self.access_token_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
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.release({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    nodeModelNames={
        'node-0001'
    },
    config=nil,
})

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

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;

releaseByUserId

Release an status by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
nodeModelNames	List<string>	✓		1 ~ 1000 items	List of node model names
config	List<Config>		[]	~ 32 items	Set values to be applied to stamp sheet variables

Result

	Type	Description
item	Status	Status
transactionId	string	Transaction ID of the stamp sheet issued
stampSheet	string	Stamp sheets used to execute the release process
stampSheetEncryptionKeyId	string	Cryptographic key GRN used for stamp sheet signature calculations
autoRunStampSheet	bool?	Is stamp sheet auto-execution enabled?

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.ReleaseByUserId(
    &skill_tree.ReleaseByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        NodeModelNames: []*string{
            pointy.String("node-0001"),
        },
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->releaseByUserId(
        (new ReleaseByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withNodeModelNames([    "node-0001",
            ])
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
} 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("namespace1")
            .withUserId("user-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();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.ReleaseByUserIdRequest;
using Gs2.Gs2SkillTree.Result.ReleaseByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ReleaseByUserIdResult> asyncResult = null;
yield return client.ReleaseByUserId(
    new Gs2.Gs2SkillTree.Request.ReleaseByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-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;

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("namespace1")
            .withUserId("user-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();
} 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(self.hash1)
            .with_user_id('user-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
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.release_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    nodeModelNames={
        'node-0001'
    },
    config=nil,
})

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

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;

markRestrainByUserId

Restrain an status by user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 32 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
nodeModelNames	List<string>	✓	1 ~ 1000 items	List of node model names

Result

	Type	Description
item	Status	Status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.MarkRestrainByUserId(
    &skill_tree.MarkRestrainByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        NodeModelNames: []*string{
            pointy.String("node-0001"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->markRestrainByUserId(
        (new MarkRestrainByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-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.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("namespace1")
            .withUserId("user-0001")
            .withNodeModelNames(Arrays.asList(
                "node-0001"
            ))
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.MarkRestrainByUserIdRequest;
using Gs2.Gs2SkillTree.Result.MarkRestrainByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.MarkRestrainByUserIdResult> asyncResult = null;
yield return client.MarkRestrainByUserId(
    new Gs2.Gs2SkillTree.Request.MarkRestrainByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-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.markRestrainByUserId(
        new Gs2SkillTree.MarkRestrainByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-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_by_user_id(
        skill_tree.MarkRestrainByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_node_model_names([    'node-0001',
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.mark_restrain_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    nodeModelNames={
        'node-0001'
    },
})

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

result = api_result.result
item = result.item;

restrain

Restrain an status

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
nodeModelNames	List<string>	✓		1 ~ 1000 items	List of node model names
config	List<Config>		[]	~ 32 items	Set values to be applied to stamp sheet variables

Result

	Type	Description
item	Status	Status
transactionId	string	Transaction ID of the stamp sheet issued
stampSheet	string	Stamp sheets used to execute the restrain process
stampSheetEncryptionKeyId	string	Cryptographic key GRN used for stamp sheet signature calculations
autoRunStampSheet	bool?	Is stamp sheet auto-execution enabled?

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.Restrain(
    &skill_tree.RestrainRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        NodeModelNames: []*string{
            pointy.String("node-0001"),
        },
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->restrain(
        (new RestrainRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withNodeModelNames([    "node-0001",
            ])
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
} 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("namespace1")
            .withAccessToken("$access_token_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();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.RestrainRequest;
using Gs2.Gs2SkillTree.Result.RestrainResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.RestrainResult> asyncResult = null;
yield return client.Restrain(
    new Gs2.Gs2SkillTree.Request.RestrainRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_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;

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("namespace1")
            .withAccessToken("$access_token_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();
} 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(self.hash1)
            .with_access_token(self.access_token_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
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.restrain({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    nodeModelNames={
        'node-0001'
    },
    config=nil,
})

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

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;

restrainByUserId

Restrain an status by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
nodeModelNames	List<string>	✓		1 ~ 1000 items	List of node model names
config	List<Config>		[]	~ 32 items	Set values to be applied to stamp sheet variables

Result

	Type	Description
item	Status	Status
transactionId	string	Transaction ID of the stamp sheet issued
stampSheet	string	Stamp sheets used to execute the restrain process
stampSheetEncryptionKeyId	string	Cryptographic key GRN used for stamp sheet signature calculations
autoRunStampSheet	bool?	Is stamp sheet auto-execution enabled?

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.RestrainByUserId(
    &skill_tree.RestrainByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        NodeModelNames: []*string{
            pointy.String("node-0001"),
        },
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->restrainByUserId(
        (new RestrainByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withNodeModelNames([    "node-0001",
            ])
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
} 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("namespace1")
            .withUserId("user-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();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.RestrainByUserIdRequest;
using Gs2.Gs2SkillTree.Result.RestrainByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.RestrainByUserIdResult> asyncResult = null;
yield return client.RestrainByUserId(
    new Gs2.Gs2SkillTree.Request.RestrainByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-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;

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("namespace1")
            .withUserId("user-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();
} 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(self.hash1)
            .with_user_id('user-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
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.restrain_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    nodeModelNames={
        'node-0001'
    },
    config=nil,
})

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

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;

getStatus

Get an status

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name
accessToken	string		✓		~ 128 chars	User Id

Result

	Type	Description
item	Status	Status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.GetStatus(
    &skill_tree.GetStatusRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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\GetStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getStatus(
        (new GetStatusRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
    );
    $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("namespace1")
            .withAccessToken("$access_token_0001")
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.GetStatusRequest;
using Gs2.Gs2SkillTree.Result.GetStatusResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetStatusResult> asyncResult = null;
yield return client.GetStatus(
    new Gs2.Gs2SkillTree.Request.GetStatusRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_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("namespace1")
            .withAccessToken("$access_token_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(self.hash1)
            .with_access_token(self.access_token_0001)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.get_status({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
})

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

result = api_result.result
item = result.item;

getStatusByUserId

Get status by user ID

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name
userId	string		✓		~ 128 chars	User Id

Result

	Type	Description
item	Status	Status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.GetStatusByUserId(
    &skill_tree.GetStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getStatusByUserId(
        (new GetStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-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.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("namespace1")
            .withUserId("user-0001")
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.GetStatusByUserIdRequest;
using Gs2.Gs2SkillTree.Result.GetStatusByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetStatusByUserIdResult> asyncResult = null;
yield return client.GetStatusByUserId(
    new Gs2.Gs2SkillTree.Request.GetStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-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.getStatusByUserId(
        new Gs2SkillTree.GetStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-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_by_user_id(
        skill_tree.GetStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.get_status_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
})

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

result = api_result.result
item = result.item;

reset

Reset status

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
config	List<Config>		[]	~ 32 items	Set values to be applied to stamp sheet variables

Result

	Type	Description
item	Status	Status
transactionId	string	Transaction ID of the stamp sheet issued
stampSheet	string	Stamp sheets used to execute the reset process
stampSheetEncryptionKeyId	string	Cryptographic key GRN used for stamp sheet signature calculations
autoRunStampSheet	bool?	Is stamp sheet auto-execution enabled?

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.Reset(
    &skill_tree.ResetRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("$access_token_0001"),
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->reset(
        (new ResetRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
} 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("namespace1")
            .withAccessToken("$access_token_0001")
            .withConfig(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.ResetRequest;
using Gs2.Gs2SkillTree.Result.ResetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ResetResult> asyncResult = null;
yield return client.Reset(
    new Gs2.Gs2SkillTree.Request.ResetRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("$access_token_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;

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("namespace1")
            .withAccessToken("$access_token_0001")
            .withConfig(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
} 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(self.hash1)
            .with_access_token(self.access_token_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
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.reset({
    namespaceName='namespace1',
    accessToken='$access_token_0001',
    config=nil,
})

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

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;

resetByUserId

Reset status by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 32 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
config	List<Config>		[]	~ 32 items	Set values to be applied to stamp sheet variables

Result

	Type	Description
item	Status	Status
transactionId	string	Transaction ID of the stamp sheet issued
stampSheet	string	Stamp sheets used to execute the reset process
stampSheetEncryptionKeyId	string	Cryptographic key GRN used for stamp sheet signature calculations
autoRunStampSheet	bool?	Is stamp sheet auto-execution enabled?

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.ResetByUserId(
    &skill_tree.ResetByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet

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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->resetByUserId(
        (new ResetByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withConfig(null)
    );
    $item = $result->getItem();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
} 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("namespace1")
            .withUserId("user-0001")
            .withConfig(null)
    );
    Status item = result.getItem();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.ResetByUserIdRequest;
using Gs2.Gs2SkillTree.Result.ResetByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ResetByUserIdResult> asyncResult = null;
yield return client.ResetByUserId(
    new Gs2.Gs2SkillTree.Request.ResetByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-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;

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("namespace1")
            .withUserId("user-0001")
            .withConfig(null)
    );
    const item = result.getItem();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
} 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(self.hash1)
            .with_user_id('user-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
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.reset_by_user_id({
    namespaceName='namespace1',
    userId='user-0001',
    config=nil,
})

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

result = api_result.result
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;

markReleaseByStampSheet

Mark an status as released by the stamp sheet

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Stamp sheet
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	Status	Status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.MarkReleaseByStampSheet(
    &skill_tree.MarkReleaseByStampSheetRequest {
        StampSheet: pointy.String("$stampSheet"),
        KeyId: pointy.String("$key1.keyId"),
    }
)
if err != nil {
    panic("error occurred")
}
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\MarkReleaseByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->markReleaseByStampSheet(
        (new MarkReleaseByStampSheetRequest())
            ->withStampSheet(self::$stampSheet)
            ->withKeyId(self::$key1.keyId)
    );
    $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.MarkReleaseByStampSheetRequest;
import io.gs2.skillTree.result.MarkReleaseByStampSheetResult;

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

try {
    MarkReleaseByStampSheetResult result = client.markReleaseByStampSheet(
        new MarkReleaseByStampSheetRequest()
            .withStampSheet("$stampSheet")
            .withKeyId("$key1.keyId")
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.MarkReleaseByStampSheetRequest;
using Gs2.Gs2SkillTree.Result.MarkReleaseByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.MarkReleaseByStampSheetResult> asyncResult = null;
yield return client.MarkReleaseByStampSheet(
    new Gs2.Gs2SkillTree.Request.MarkReleaseByStampSheetRequest()
        .WithStampSheet("$stampSheet")
        .WithKeyId("$key1.keyId"),
    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.markReleaseByStampSheet(
        new Gs2SkillTree.MarkReleaseByStampSheetRequest()
            .withStampSheet("$stampSheet")
            .withKeyId("$key1.keyId")
    );
    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_stamp_sheet(
        skill_tree.MarkReleaseByStampSheetRequest()
            .with_stamp_sheet(self.stamp_sheet)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.mark_release_by_stamp_sheet({
    stampSheet='$stampSheet',
    keyId='$key1.keyId',
})

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

result = api_result.result
item = result.item;

markRestrainByStampTask

Delete an status by the stamp sheet

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Stamp task
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	Status	Status
newContextStack	string	Request of context in which stamp task execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.MarkRestrainByStampTask(
    &skill_tree.MarkRestrainByStampTaskRequest {
        StampTask: pointy.String("$stampTask"),
        KeyId: pointy.String("$key1.keyId"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
newContextStack := result.NewContextStack

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\MarkRestrainByStampTaskRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->markRestrainByStampTask(
        (new MarkRestrainByStampTaskRequest())
            ->withStampTask(self::$stampTask)
            ->withKeyId(self::$key1.keyId)
    );
    $item = $result->getItem();
    $newContextStack = $result->getNewContextStack();
} 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.MarkRestrainByStampTaskRequest;
import io.gs2.skillTree.result.MarkRestrainByStampTaskResult;

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

try {
    MarkRestrainByStampTaskResult result = client.markRestrainByStampTask(
        new MarkRestrainByStampTaskRequest()
            .withStampTask("$stampTask")
            .withKeyId("$key1.keyId")
    );
    Status item = result.getItem();
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.MarkRestrainByStampTaskRequest;
using Gs2.Gs2SkillTree.Result.MarkRestrainByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.MarkRestrainByStampTaskResult> asyncResult = null;
yield return client.MarkRestrainByStampTask(
    new Gs2.Gs2SkillTree.Request.MarkRestrainByStampTaskRequest()
        .WithStampTask("$stampTask")
        .WithKeyId("$key1.keyId"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var newContextStack = result.NewContextStack;

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.markRestrainByStampTask(
        new Gs2SkillTree.MarkRestrainByStampTaskRequest()
            .withStampTask("$stampTask")
            .withKeyId("$key1.keyId")
    );
    const item = result.getItem();
    const newContextStack = result.getNewContextStack();
} 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_stamp_task(
        skill_tree.MarkRestrainByStampTaskRequest()
            .with_stamp_task(self.stamp_task)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.mark_restrain_by_stamp_task({
    stampTask='$stampTask',
    keyId='$key1.keyId',
})

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

result = api_result.result
item = result.item;
newContextStack = result.newContextStack;

exportMaster

Export master data for currently available status settings

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name

Result

	Type	Description
item	CurrentTreeMaster	Currently available status settings

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.ExportMaster(
    &skill_tree.ExportMasterRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->exportMaster(
        (new ExportMasterRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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("namespace1")
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.ExportMasterRequest;
using Gs2.Gs2SkillTree.Result.ExportMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.ExportMasterResult> asyncResult = null;
yield return client.ExportMaster(
    new Gs2.Gs2SkillTree.Request.ExportMasterRequest()
        .WithNamespaceName("namespace1"),
    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("namespace1")
    );
    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(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.export_master({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

getCurrentTreeMaster

Get the currently available status settings

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name

Result

	Type	Description
item	CurrentTreeMaster	Currently available status settings

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.GetCurrentTreeMaster(
    &skill_tree.GetCurrentTreeMasterRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getCurrentTreeMaster(
        (new GetCurrentTreeMasterRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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("namespace1")
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.GetCurrentTreeMasterRequest;
using Gs2.Gs2SkillTree.Result.GetCurrentTreeMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.GetCurrentTreeMasterResult> asyncResult = null;
yield return client.GetCurrentTreeMaster(
    new Gs2.Gs2SkillTree.Request.GetCurrentTreeMasterRequest()
        .WithNamespaceName("namespace1"),
    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("namespace1")
    );
    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(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.get_current_tree_master({
    namespaceName='namespace1',
})

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

result = api_result.result
item = result.item;

updateCurrentTreeMaster

Update the currently available status settings

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name
settings	string		✓		~ 5242880 chars	Master data

Result

	Type	Description
item	CurrentTreeMaster	Updated and currently available status settings

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentTreeMaster(
    &skill_tree.UpdateCurrentTreeMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        Settings: pointy.String("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}"),
    }
)
if err != nil {
    panic("error occurred")
}
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\UpdateCurrentTreeMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentTreeMaster(
        (new UpdateCurrentTreeMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"\namespace1\\\", \\\"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\\\": \\\"\namespace1\\\", \\\"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\\\": \\\"\namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"\namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}")
    );
    $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("namespace1")
            .withSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}")
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.UpdateCurrentTreeMasterRequest;
using Gs2.Gs2SkillTree.Result.UpdateCurrentTreeMasterResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateCurrentTreeMasterResult> asyncResult = null;
yield return client.UpdateCurrentTreeMaster(
    new Gs2.Gs2SkillTree.Request.UpdateCurrentTreeMasterRequest()
        .WithNamespaceName("namespace1")
        .WithSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}"),
    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("namespace1")
            .withSettings("{\"version\": \"2023-09-06\", \"nodeModels\": [{\"name\": \"node-0001\", \"metadata\": \"NODE-0001\", \"releaseConsumeActions\": [{\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}\"}, {\"action\": \"Gs2Inventory:ConsumeItemSetByUserId\", \"request\": \"{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}\"}], \"restrainReturnRate\": 0.5, \"premiseNodeNames\": [\"node-0002\"]}]}")
    );
    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(self.hash1)
            .with_settings('{"version": "2023-09-06", "nodeModels": [{"name": "node-0001", "metadata": "NODE-0001", "releaseConsumeActions": [{"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"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\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 20}"}, {"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\\\"namespaceName\\\": \\\"namespace1\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 2}"}], "restrainReturnRate": 0.5, "premiseNodeNames": ["node-0002"]}]}')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.update_current_tree_master({
    namespaceName='namespace1',
    settings='{"version": "2023-09-06", "nodeModels": [{"name": "node-0001", "metadata": "NODE-0001", "releaseConsumeActions": [{"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\"namespaceName\": \"namespace1\", \"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\": \"namespace1\", \"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\": \"namespace1\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 20}"}, {"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{\"namespaceName\": \"namespace1\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"consumeCount\": 2}"}], "restrainReturnRate": 0.5, "premiseNodeNames": ["node-0002"]}]}',
})

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

result = api_result.result
item = result.item;

updateCurrentTreeMasterFromGitHub

Update the currently available status settings

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 32 chars	Namespace name
checkoutSetting	GitHubCheckoutSetting		✓			Setup to check out master data from GitHub

Result

	Type	Description
item	CurrentTreeMaster	Updated currently available status settings

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/skill_tree"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := skill_tree.Gs2SkillTreeRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentTreeMasterFromGitHub(
    &skill_tree.UpdateCurrentTreeMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace1"),
        CheckoutSetting: {'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'},
    }
)
if err != nil {
    panic("error occurred")
}
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 Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentTreeMasterFromGitHub(
        (new UpdateCurrentTreeMasterFromGitHubRequest())
            ->withNamespaceName(self::namespace1)
            ->withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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("namespace1")
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    );
    CurrentTreeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2SkillTree.Gs2SkillTreeRestClient;
using Gs2.Gs2SkillTree.Request.UpdateCurrentTreeMasterFromGitHubRequest;
using Gs2.Gs2SkillTree.Result.UpdateCurrentTreeMasterFromGitHubResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2SkillTreeRestClient(session);

AsyncResult<Gs2.Gs2SkillTree.Result.UpdateCurrentTreeMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentTreeMasterFromGitHub(
    new Gs2.Gs2SkillTree.Request.UpdateCurrentTreeMasterFromGitHubRequest()
        .WithNamespaceName("namespace1")
        .WithCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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("namespace1")
            .withCheckoutSetting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': '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(self.hash1)
            .with_checkout_setting({'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'})
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('skillTree')

api_result = client.update_current_tree_master_from_git_hub({
    namespaceName='namespace1',
    checkoutSetting={'apiKeyId': '$gitHubApiKey1.apiKeyId', 'repositoryName': 'gs2io/master-data', 'sourcePath': 'path/to/file.json', 'referenceType': 'branch', 'branchName': 'develop'},
})

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

result = api_result.result
item = result.item;