API Reference of GS2-Enchant 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	✓		~ 128 chars	Namespace name
description	string			~ 1024 chars	Description
transactionSetting	TransactionSetting	✓			Transaction settings
logSetting	LogSetting				Log output settings
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

BalanceParameterModel

Balance parameter model

Defines the drawing conditions for balance parameters.

	Type	Require	Default	Limitation	Description
balanceParameterModelId	string	✓		~ 1024 chars	Balance Parameter Model GRN
name	string	✓		~ 128 chars	Balance parameter model name
metadata	string			~ 2048 chars	metadata
totalValue	long	✓		~ 9223372036854775805	Total value
initialValueStrategy	enum { “average”, “lottery” }	✓	“average”	~ 128 chars	Initial value setting policy
parameters	List<BalanceParameterValueModel>	✓		1 ~ 10 items	Balance parameter value model list

Enumeration type definition to specify as initialValueStrategy

Enumerator String Definition	Description
average	Average
lottery	Lottery

BalanceParameterModelMaster

Balance parameter model master

Defines the drawing conditions for balance parameters.

	Type	Require	Default	Limitation	Description
balanceParameterModelId	string	✓		~ 1024 chars	Balance Parameter Model GRN
name	string	✓		~ 128 chars	Balance parameter model name
description	string			~ 1024 chars	Description
metadata	string			~ 2048 chars	metadata
totalValue	long	✓		~ 9223372036854775805	Total value
initialValueStrategy	enum { “average”, “lottery” }	✓	“average”	~ 128 chars	Initial value setting policy
parameters	List<BalanceParameterValueModel>	✓		1 ~ 10 items	Balance parameter value model list
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

Enumeration type definition to specify as initialValueStrategy

Enumerator String Definition	Description
average	Average
lottery	Lottery

RarityParameterModel

Balance parameter model

Defines the drawing conditions for balance parameters.

	Type	Require	Limitation	Description
rarityParameterModelId	string	✓	~ 1024 chars	Rarity Parameter Model GRN
name	string	✓	~ 128 chars	Balance parameter model name
metadata	string		~ 2048 chars	metadata
maximumParameterCount	int	✓	1 ~ 10	Maximum number of parameters to be given
parameterCounts	List<RarityParameterCountModel>	✓	1 ~ 10 items	Rarity parameter value model list
parameters	List<RarityParameterValueModel>	✓	1 ~ 1000 items	Rarity parameter value model list

RarityParameterModelMaster

Rarity parameter model master

Defines the drawing conditions for balance parameters.

	Type	Require	Default	Limitation	Description
rarityParameterModelId	string	✓		~ 1024 chars	Rarity Parameter Model GRN
name	string	✓		~ 128 chars	Rarity parameter model name
description	string			~ 1024 chars	Description
metadata	string			~ 2048 chars	metadata
maximumParameterCount	int	✓		1 ~ 10	Maximum number of parameters to be given
parameterCounts	List<RarityParameterCountModel>	✓		1 ~ 10 items	Rarity parameter value model list
parameters	List<RarityParameterValueModel>	✓		1 ~ 1000 items	Rarity parameter value model list
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

CurrentParameterMaster

Currently available enchantd rate masters

GS2 uses JSON format files for master data management. By uploading the file, the settings can actually be reflected 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 your own 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.

Note

Please refer to Master Data Reference of GS2-Enchant for the JSON file format.

	Type	Condition	Require	Default	Limitation	Description
namespaceId	string		✓		~ 1024 chars	Currently available enchant parameter setting GRN
settings	string		✓		~ 5242880 chars	Master data

BalanceParameterStatus

Balance parameter status

	Type	Require	Default	Limitation	Description
balanceParameterStatusId	string	✓		~ 1024 chars	Balance Parameter GRN
userId	string	✓		~ 128 chars	User Id
parameterName	string	✓		~ 128 chars	Balance parameter model name
propertyId	string	✓		~ 1024 chars	Property ID of the resource that owns the parameter
parameterValues	List<BalanceParameterValue>	✓		1 ~ 10 items	List of balance parameter values
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

RarityParameterStatus

Rarity parameter status

	Type	Require	Default	Limitation	Description
rarityParameterStatusId	string	✓		~ 1024 chars	Rarity Parameter GRN
userId	string	✓		~ 128 chars	User Id
parameterName	string	✓		~ 128 chars	Rarity parameter model name
propertyId	string	✓		~ 1024 chars	Property ID of the resource that owns the parameter
parameterValues	List<RarityParameterValue>			~ 10 items	List of rarity parameter values
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

BalanceParameterValueModel

Balance Parameter Value Model

	Type	Condition	Require	Default	Limitation	Description
name	string		✓		~ 64 chars	Name
metadata	string				~ 512 chars	metadata

RarityParameterCountModel

Model of the number of rarity parameters granted

	Type	Condition	Require	Default	Limitation	Description
count	int		✓		~ 10	Value
weight	int		✓		1 ~ 2147483646	Weight

RarityParameterValueModel

Balance Parameter Value Model

	Type	Require	Limitation	Description
name	string	✓	~ 64 chars	Name
metadata	string		~ 512 chars	metadata
resourceName	string	✓	~ 64 chars	Parameter Resource Name for Game(Not used for GS2)
resourceValue	long	✓	~ 9223372036854775805	Parameter Resource Value for Game(Not used for GS2)
weight	int	✓	1 ~ 2147483646	Weight

BalanceParameterValue

Balance Parameter Value Model

	Type	Condition	Require	Default	Limitation	Description
name	string		✓		~ 64 chars	Name
value	long		✓		~ 9223372036854775805	Value

RarityParameterValue

Rarity Parameter Value Model

	Type	Require	Limitation	Description
name	string	✓	~ 64 chars	Name
resourceName	string	✓	~ 64 chars	Resource Name
resourceValue	long	✓	~ 9223372036854775805	Resource Value

Config

Configration

Set values to be applied to transaction variables

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

GitHubCheckoutSetting

Setup to check out master data from GitHub

	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

Enumeration type definition to specify as referenceType

Enumerator String Definition	Description
commit_hash	Commit hash
branch	Branch
tag	Tag

ScriptSetting

Script settings

In GS2, you can associate custom scripts with microservice events and execute them. This model holds the settings for triggering script execution.

There are two main ways to execute a script: synchronous execution and asynchronous execution. Synchronous execution blocks processing until the script has finished executing. Instead, you can use the script execution result to stop the execution of the API or to tamper with the result of the API.

On the other hand, asynchronous execution does not block processing until the script has finished executing. Instead, you can use the script execution result to stop the execution of the API or to tamper with the result of the API. However, asynchronous execution does not block processing until the script has finished executing, so it is generally recommended to use asynchronous execution.

There are two types of asynchronous execution methods: GS2-Script and Amazon EventBridge. By using Amazon EventBridge, you can write processing in languages other than Lua.

	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

Enumeration type definition to specify as doneTriggerTargetType

Enumerator String Definition	Description
none	None
gs2_script	GS2-Script
aws	Amazon EventBridge

LogSetting

Log setting

This type manages log output settings. This type holds the identifier of the log namespace used to output log data. The log namespace ID specifies the GS2-Log namespace to aggregate and store the log data. Through this setting, API request and response log data under this namespace will be output to the target GS2-Log. GS2-Log provides logs in real time, which can be used for system monitoring, analysis, debugging, etc.

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

TransactionSetting

Transaction settings

	Type	Require	Default	Limitation	Description
enableAutoRun	bool	✓	false		Automatically run issued transactions on the server side, or
distributorNamespaceId	string	✓	“grn:gs2:{region}:{ownerId}:distributor:default”	~ 1024 chars	GS2-Distributor namespace used for transaction execution
queueNamespaceId	string	✓	“grn:gs2:{region}:{ownerId}:queue:default”	~ 1024 chars	Namespace in GS2-JobQueue used to run the transaction

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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &enchant.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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeNamespacesRequest;
import io.gs2.enchant.result.DescribeNamespacesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2EnchantRestClient client = new Gs2EnchantRestClient(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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeNamespacesRequest;
using Gs2.Gs2Enchant.Result.DescribeNamespacesResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2Enchant.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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeNamespaces(
        new Gs2Enchant.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 enchant

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

try:
    result = client.describe_namespaces(
        enchant.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('enchant')

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;

client = gs2('enchant')

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

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

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

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

createNamespace

Create a new namespace

Request

	Type	Require	Limitation	Description
name	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
transactionSetting	TransactionSetting	✓		Transaction settings
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &enchant.CreateNamespaceRequest {
        Name: pointy.String("namespace1"),
        Description: nil,
        TransactionSetting: &enchant.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"),
        },
        LogSetting: &enchant.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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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\Enchant\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"))
            ->withLogSetting((new \Gs2\Enchant\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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.CreateNamespaceRequest;
import io.gs2.enchant.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withTransactionSetting(new io.gs2.enchant.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"))
            .withLogSetting(new io.gs2.enchant.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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.CreateNamespaceRequest;
using Gs2.Gs2Enchant.Result.CreateNamespaceResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Enchant.Request.CreateNamespaceRequest()
        .WithName("namespace1")
        .WithDescription(null)
        .WithTransactionSetting(new Gs2.Gs2Enchant.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"))
        .WithLogSetting(new Gs2.Gs2Enchant.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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.createNamespace(
        new Gs2Enchant.CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withTransactionSetting(new Gs2Enchant.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"))
            .withLogSetting(new Gs2Enchant.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 enchant

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

try:
    result = client.create_namespace(
        enchant.CreateNamespaceRequest()
            .with_name(self.hash1)
            .with_description(None)
            .with_transaction_setting(
                enchant.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_log_setting(
                enchant.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('enchant')

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",
    },
    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;

client = gs2('enchant')

api_result_handler = client.create_namespace_async({
    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",
    },
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1",
    },
})

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

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

result = api_result.result
item = result.item;

getNamespaceStatus

Get namespace status

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &enchant.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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetNamespaceStatusRequest;
import io.gs2.enchant.result.GetNamespaceStatusResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2EnchantRestClient client = new Gs2EnchantRestClient(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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetNamespaceStatusRequest;
using Gs2.Gs2Enchant.Result.GetNamespaceStatusResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2Enchant.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 Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_namespace_status(
        enchant.GetNamespaceStatusRequest()
            .with_namespace_name(self.hash1)
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

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;

client = gs2('enchant')

api_result_handler = client.get_namespace_status_async({
    namespaceName="namespace1",
})

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

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

result = api_result.result
status = result.status;

getNamespace

Get namespace

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &enchant.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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetNamespaceRequest;
import io.gs2.enchant.result.GetNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2EnchantRestClient client = new Gs2EnchantRestClient(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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetNamespaceRequest;
using Gs2.Gs2Enchant.Result.GetNamespaceResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2Enchant.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 Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_namespace(
        enchant.GetNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

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;

client = gs2('enchant')

api_result_handler = client.get_namespace_async({
    namespaceName="namespace1",
})

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

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

result = api_result.result
item = result.item;

updateNamespace

Update namespace

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
transactionSetting	TransactionSetting	✓		Transaction settings
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &enchant.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
        Description: pointy.String("description1"),
        TransactionSetting: &enchant.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"),
        },
        LogSetting: &enchant.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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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\Enchant\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"))
            ->withLogSetting((new \Gs2\Enchant\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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.UpdateNamespaceRequest;
import io.gs2.enchant.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withTransactionSetting(new io.gs2.enchant.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"))
            .withLogSetting(new io.gs2.enchant.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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.UpdateNamespaceRequest;
using Gs2.Gs2Enchant.Result.UpdateNamespaceResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Enchant.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace1")
        .WithDescription("description1")
        .WithTransactionSetting(new Gs2.Gs2Enchant.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"))
        .WithLogSetting(new Gs2.Gs2Enchant.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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.updateNamespace(
        new Gs2Enchant.UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withTransactionSetting(new Gs2Enchant.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"))
            .withLogSetting(new Gs2Enchant.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 enchant

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

try:
    result = client.update_namespace(
        enchant.UpdateNamespaceRequest()
            .with_namespace_name(self.hash1)
            .with_description('description1')
            .with_transaction_setting(
                enchant.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_log_setting(
                enchant.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('enchant')

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",
    },
    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;

client = gs2('enchant')

api_result_handler = client.update_namespace_async({
    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",
    },
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1",
    },
})

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

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

result = api_result.result
item = result.item;

deleteNamespace

Delete namespace

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &enchant.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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DeleteNamespaceRequest;
import io.gs2.enchant.result.DeleteNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2EnchantRestClient client = new Gs2EnchantRestClient(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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DeleteNamespaceRequest;
using Gs2.Gs2Enchant.Result.DeleteNamespaceResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2Enchant.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 Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

try:
    result = client.delete_namespace(
        enchant.DeleteNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

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;

client = gs2('enchant')

api_result_handler = client.delete_namespace_async({
    namespaceName="namespace1",
})

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

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['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
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DumpUserDataByUserId(
    &enchant.DumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

try {
    DumpUserDataByUserIdResult result = client.dumpUserDataByUserId(
        new DumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DumpUserDataByUserIdRequest;
using Gs2.Gs2Enchant.Result.DumpUserDataByUserIdResult;

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

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

client = gs2('enchant')

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

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

result = api_result.result

client = gs2('enchant')

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

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

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['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
timeOffsetToken	string				~ 1024 chars	Time offset token

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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
    &enchant.CheckDumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

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

client = gs2('enchant')

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

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

result = api_result.result
url = result.url;

client = gs2('enchant')

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

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

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['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
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.CleanUserDataByUserId(
    &enchant.CleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

try {
    CleanUserDataByUserIdResult result = client.cleanUserDataByUserId(
        new CleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.CleanUserDataByUserIdRequest;
using Gs2.Gs2Enchant.Result.CleanUserDataByUserIdResult;

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

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

client = gs2('enchant')

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

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

result = api_result.result

client = gs2('enchant')

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

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

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['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
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
    &enchant.CheckCleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

try {
    CheckCleanUserDataByUserIdResult result = client.checkCleanUserDataByUserId(
        new CheckCleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.CheckCleanUserDataByUserIdRequest;
using Gs2.Gs2Enchant.Result.CheckCleanUserDataByUserIdResult;

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

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

client = gs2('enchant')

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

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

result = api_result.result

client = gs2('enchant')

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

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

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['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
timeOffsetToken	string				~ 1024 chars	Time offset token

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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
    &enchant.PrepareImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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")
            ->withTimeOffsetToken(null)
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

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

client = gs2('enchant')

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

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

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

client = gs2('enchant')

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

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

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

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

importUserDataByUserId

Start importing data associated with the specified user ID

Request

	Type	Require	Limitation	Description
userId	string	✓	~ 128 chars	User Id
uploadToken	string	✓	~ 1024 chars	Token received in preparation for upload
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.ImportUserDataByUserId(
    &enchant.ImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

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

client = gs2('enchant')

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

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

result = api_result.result

client = gs2('enchant')

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

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

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

result = api_result.result

checkImportUserDataByUserId

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

Request

	Type	Require	Limitation	Description
userId	string	✓	~ 128 chars	User Id
uploadToken	string	✓	~ 1024 chars	Token received in preparation for upload
timeOffsetToken	string		~ 1024 chars	Time offset token

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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
    &enchant.CheckImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

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

client = gs2('enchant')

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

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

result = api_result.result
url = result.url;

client = gs2('enchant')

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

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

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

result = api_result.result
url = result.url;

describeBalanceParameterModels

Get list of Balance Parameter Models

Request

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

Result

	Type	Description
items	List<BalanceParameterModel>	List of Balance Parameter Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeBalanceParameterModels(
    &enchant.DescribeBalanceParameterModelsRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeBalanceParameterModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBalanceParameterModels(
        (new DescribeBalanceParameterModelsRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeBalanceParameterModelsRequest;
import io.gs2.enchant.result.DescribeBalanceParameterModelsResult;

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

try {
    DescribeBalanceParameterModelsResult result = client.describeBalanceParameterModels(
        new DescribeBalanceParameterModelsRequest()
            .withNamespaceName("namespace1")
    );
    List<BalanceParameterModel> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeBalanceParameterModelsRequest;
using Gs2.Gs2Enchant.Result.DescribeBalanceParameterModelsResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeBalanceParameterModelsResult> asyncResult = null;
yield return client.DescribeBalanceParameterModels(
    new Gs2.Gs2Enchant.Request.DescribeBalanceParameterModelsRequest()
        .WithNamespaceName("namespace1"),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeBalanceParameterModels(
        new Gs2Enchant.DescribeBalanceParameterModelsRequest()
            .withNamespaceName("namespace1")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.describe_balance_parameter_models(
        enchant.DescribeBalanceParameterModelsRequest()
            .with_namespace_name(self.hash1)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.describe_balance_parameter_models({
    namespaceName="namespace1",
})

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

result = api_result.result
items = result.items;

client = gs2('enchant')

api_result_handler = client.describe_balance_parameter_models_async({
    namespaceName="namespace1",
})

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

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

result = api_result.result
items = result.items;

getBalanceParameterModel

Get Balance Parameter Model

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Balance parameter model name

Result

	Type	Description
item	BalanceParameterModel	Balance Parameter Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetBalanceParameterModel(
    &enchant.GetBalanceParameterModelRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("balance-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetBalanceParameterModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBalanceParameterModel(
        (new GetBalanceParameterModelRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("balance-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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetBalanceParameterModelRequest;
import io.gs2.enchant.result.GetBalanceParameterModelResult;

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

try {
    GetBalanceParameterModelResult result = client.getBalanceParameterModel(
        new GetBalanceParameterModelRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
    );
    BalanceParameterModel 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetBalanceParameterModelRequest;
using Gs2.Gs2Enchant.Result.GetBalanceParameterModelResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetBalanceParameterModelResult> asyncResult = null;
yield return client.GetBalanceParameterModel(
    new Gs2.Gs2Enchant.Request.GetBalanceParameterModelRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("balance-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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getBalanceParameterModel(
        new Gs2Enchant.GetBalanceParameterModelRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_balance_parameter_model(
        enchant.GetBalanceParameterModelRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('balance-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_balance_parameter_model({
    namespaceName="namespace1",
    parameterName="balance-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_balance_parameter_model_async({
    namespaceName="namespace1",
    parameterName="balance-0001",
})

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

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

result = api_result.result
item = result.item;

describeBalanceParameterModelMasters

Get list of Balance Parameter Model Masters

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 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<BalanceParameterModelMaster>	List of Balance Parameter Model Master
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeBalanceParameterModelMasters(
    &enchant.DescribeBalanceParameterModelMastersRequest {
        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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeBalanceParameterModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBalanceParameterModelMasters(
        (new DescribeBalanceParameterModelMastersRequest())
            ->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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeBalanceParameterModelMastersRequest;
import io.gs2.enchant.result.DescribeBalanceParameterModelMastersResult;

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

try {
    DescribeBalanceParameterModelMastersResult result = client.describeBalanceParameterModelMasters(
        new DescribeBalanceParameterModelMastersRequest()
            .withNamespaceName("namespace1")
            .withPageToken(null)
            .withLimit(null)
    );
    List<BalanceParameterModelMaster> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeBalanceParameterModelMastersRequest;
using Gs2.Gs2Enchant.Result.DescribeBalanceParameterModelMastersResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeBalanceParameterModelMastersResult> asyncResult = null;
yield return client.DescribeBalanceParameterModelMasters(
    new Gs2.Gs2Enchant.Request.DescribeBalanceParameterModelMastersRequest()
        .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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeBalanceParameterModelMasters(
        new Gs2Enchant.DescribeBalanceParameterModelMastersRequest()
            .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 enchant

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

try:
    result = client.describe_balance_parameter_model_masters(
        enchant.DescribeBalanceParameterModelMastersRequest()
            .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('enchant')

api_result = client.describe_balance_parameter_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;

client = gs2('enchant')

api_result_handler = client.describe_balance_parameter_model_masters_async({
    namespaceName="namespace1",
    pageToken=nil,
    limit=nil,
})

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

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

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

createBalanceParameterModelMaster

Create a new Balance Parameter Model Master

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
name	string	✓		~ 128 chars	Balance parameter model name
description	string			~ 1024 chars	Description
metadata	string			~ 2048 chars	metadata
totalValue	long	✓		~ 9223372036854775805	Total value
initialValueStrategy	enum { “average”, “lottery” }	✓	“average”	~ 128 chars	Initial value setting policy
parameters	List<BalanceParameterValueModel>	✓		1 ~ 10 items	Balance parameter value model list

Enumeration type definition to specify as initialValueStrategy

Enumerator String Definition	Description
average	Average
lottery	Lottery

Result

	Type	Description
item	BalanceParameterModelMaster	Created Balance Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.CreateBalanceParameterModelMaster(
    &enchant.CreateBalanceParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        Name: pointy.String("balance-0001"),
        Description: nil,
        Metadata: nil,
        TotalValue: pointy.Int64(100),
        InitialValueStrategy: pointy.String("average"),
        Parameters: []enchant.BalanceParameterValueModel{
            enchant.BalanceParameterValueModel{
                Name: pointy.String("parameter-0001"),
            },
            enchant.BalanceParameterValueModel{
                Name: pointy.String("parameter-0002"),
            },
            enchant.BalanceParameterValueModel{
                Name: pointy.String("parameter-0003"),
            },
        },
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\CreateBalanceParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createBalanceParameterModelMaster(
        (new CreateBalanceParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withName("balance-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withTotalValue(100)
            ->withInitialValueStrategy("average")
            ->withParameters([
                (new \Gs2\Enchant\Model\BalanceParameterValueModel())
                    ->withName("parameter-0001"),
                (new \Gs2\Enchant\Model\BalanceParameterValueModel())
                    ->withName("parameter-0002"),
                (new \Gs2\Enchant\Model\BalanceParameterValueModel())
                    ->withName("parameter-0003"),
            ])
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.CreateBalanceParameterModelMasterRequest;
import io.gs2.enchant.result.CreateBalanceParameterModelMasterResult;

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

try {
    CreateBalanceParameterModelMasterResult result = client.createBalanceParameterModelMaster(
        new CreateBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withName("balance-0001")
            .withDescription(null)
            .withMetadata(null)
            .withTotalValue(100L)
            .withInitialValueStrategy("average")
            .withParameters(Arrays.asList(
                new io.gs2.enchant.model.BalanceParameterValueModel()
                    .withName("parameter-0001"),
                new io.gs2.enchant.model.BalanceParameterValueModel()
                    .withName("parameter-0002"),
                new io.gs2.enchant.model.BalanceParameterValueModel()
                    .withName("parameter-0003")
            ))
    );
    BalanceParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.CreateBalanceParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.CreateBalanceParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.CreateBalanceParameterModelMasterResult> asyncResult = null;
yield return client.CreateBalanceParameterModelMaster(
    new Gs2.Gs2Enchant.Request.CreateBalanceParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithName("balance-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithTotalValue(100L)
        .WithInitialValueStrategy("average")
        .WithParameters(new Gs2.Gs2Enchant.Model.BalanceParameterValueModel[] {
            new Gs2.Gs2Enchant.Model.BalanceParameterValueModel()
                .WithName("parameter-0001"),
            new Gs2.Gs2Enchant.Model.BalanceParameterValueModel()
                .WithName("parameter-0002"),
            new Gs2.Gs2Enchant.Model.BalanceParameterValueModel()
                .WithName("parameter-0003"),
        }),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.createBalanceParameterModelMaster(
        new Gs2Enchant.CreateBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withName("balance-0001")
            .withDescription(null)
            .withMetadata(null)
            .withTotalValue(100)
            .withInitialValueStrategy("average")
            .withParameters([
                new Gs2Enchant.model.BalanceParameterValueModel()
                    .withName("parameter-0001"),
                new Gs2Enchant.model.BalanceParameterValueModel()
                    .withName("parameter-0002"),
                new Gs2Enchant.model.BalanceParameterValueModel()
                    .withName("parameter-0003"),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.create_balance_parameter_model_master(
        enchant.CreateBalanceParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_name('balance-0001')
            .with_description(None)
            .with_metadata(None)
            .with_total_value(100)
            .with_initial_value_strategy('average')
            .with_parameters([
                enchant.BalanceParameterValueModel()
                    .with_name('parameter-0001'),
                enchant.BalanceParameterValueModel()
                    .with_name('parameter-0002'),
                enchant.BalanceParameterValueModel()
                    .with_name('parameter-0003'),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.create_balance_parameter_model_master({
    namespaceName="namespace1",
    name="balance-0001",
    description=nil,
    metadata=nil,
    totalValue=100,
    initialValueStrategy="average",
    parameters={
        {
            name="parameter-0001",
        },
        {
            name="parameter-0002",
        },
        {
            name="parameter-0003",
        }
    },
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.create_balance_parameter_model_master_async({
    namespaceName="namespace1",
    name="balance-0001",
    description=nil,
    metadata=nil,
    totalValue=100,
    initialValueStrategy="average",
    parameters={
        {
            name="parameter-0001",
        },
        {
            name="parameter-0002",
        },
        {
            name="parameter-0003",
        }
    },
})

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

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

result = api_result.result
item = result.item;

getBalanceParameterModelMaster

Get Balance Parameter Model Master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Balance parameter model name

Result

	Type	Description
item	BalanceParameterModelMaster	Balance Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetBalanceParameterModelMaster(
    &enchant.GetBalanceParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("balance-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetBalanceParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBalanceParameterModelMaster(
        (new GetBalanceParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("balance-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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetBalanceParameterModelMasterRequest;
import io.gs2.enchant.result.GetBalanceParameterModelMasterResult;

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

try {
    GetBalanceParameterModelMasterResult result = client.getBalanceParameterModelMaster(
        new GetBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
    );
    BalanceParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetBalanceParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.GetBalanceParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetBalanceParameterModelMasterResult> asyncResult = null;
yield return client.GetBalanceParameterModelMaster(
    new Gs2.Gs2Enchant.Request.GetBalanceParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("balance-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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getBalanceParameterModelMaster(
        new Gs2Enchant.GetBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_balance_parameter_model_master(
        enchant.GetBalanceParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('balance-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_balance_parameter_model_master({
    namespaceName="namespace1",
    parameterName="balance-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_balance_parameter_model_master_async({
    namespaceName="namespace1",
    parameterName="balance-0001",
})

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

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

result = api_result.result
item = result.item;

updateBalanceParameterModelMaster

Update Balance Parameter Model Master

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
parameterName	string	✓		~ 128 chars	Balance parameter model name
description	string			~ 1024 chars	Description
metadata	string			~ 2048 chars	metadata
totalValue	long	✓		~ 9223372036854775805	Total value
initialValueStrategy	enum { “average”, “lottery” }	✓	“average”	~ 128 chars	Initial value setting policy
parameters	List<BalanceParameterValueModel>	✓		1 ~ 10 items	Balance parameter value model list

Enumeration type definition to specify as initialValueStrategy

Enumerator String Definition	Description
average	Average
lottery	Lottery

Result

	Type	Description
item	BalanceParameterModelMaster	Updated Balance Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.UpdateBalanceParameterModelMaster(
    &enchant.UpdateBalanceParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("balance-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("BALANCE_0001"),
        TotalValue: pointy.Int64(200),
        InitialValueStrategy: pointy.String("lottery"),
        Parameters: []enchant.BalanceParameterValueModel{
            enchant.BalanceParameterValueModel{
                Name: pointy.String("parameter-1001"),
            },
            enchant.BalanceParameterValueModel{
                Name: pointy.String("parameter-1002"),
            },
            enchant.BalanceParameterValueModel{
                Name: pointy.String("parameter-1003"),
            },
            enchant.BalanceParameterValueModel{
                Name: pointy.String("parameter-1004"),
            },
        },
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\UpdateBalanceParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateBalanceParameterModelMaster(
        (new UpdateBalanceParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("balance-0001")
            ->withDescription("description1")
            ->withMetadata("BALANCE_0001")
            ->withTotalValue(200)
            ->withInitialValueStrategy("lottery")
            ->withParameters([
                (new \Gs2\Enchant\Model\BalanceParameterValueModel())
                    ->withName("parameter-1001"),
                (new \Gs2\Enchant\Model\BalanceParameterValueModel())
                    ->withName("parameter-1002"),
                (new \Gs2\Enchant\Model\BalanceParameterValueModel())
                    ->withName("parameter-1003"),
                (new \Gs2\Enchant\Model\BalanceParameterValueModel())
                    ->withName("parameter-1004"),
            ])
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.UpdateBalanceParameterModelMasterRequest;
import io.gs2.enchant.result.UpdateBalanceParameterModelMasterResult;

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

try {
    UpdateBalanceParameterModelMasterResult result = client.updateBalanceParameterModelMaster(
        new UpdateBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
            .withDescription("description1")
            .withMetadata("BALANCE_0001")
            .withTotalValue(200L)
            .withInitialValueStrategy("lottery")
            .withParameters(Arrays.asList(
                new io.gs2.enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1001"),
                new io.gs2.enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1002"),
                new io.gs2.enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1003"),
                new io.gs2.enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1004")
            ))
    );
    BalanceParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.UpdateBalanceParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.UpdateBalanceParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.UpdateBalanceParameterModelMasterResult> asyncResult = null;
yield return client.UpdateBalanceParameterModelMaster(
    new Gs2.Gs2Enchant.Request.UpdateBalanceParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("balance-0001")
        .WithDescription("description1")
        .WithMetadata("BALANCE_0001")
        .WithTotalValue(200L)
        .WithInitialValueStrategy("lottery")
        .WithParameters(new Gs2.Gs2Enchant.Model.BalanceParameterValueModel[] {
            new Gs2.Gs2Enchant.Model.BalanceParameterValueModel()
                .WithName("parameter-1001"),
            new Gs2.Gs2Enchant.Model.BalanceParameterValueModel()
                .WithName("parameter-1002"),
            new Gs2.Gs2Enchant.Model.BalanceParameterValueModel()
                .WithName("parameter-1003"),
            new Gs2.Gs2Enchant.Model.BalanceParameterValueModel()
                .WithName("parameter-1004"),
        }),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.updateBalanceParameterModelMaster(
        new Gs2Enchant.UpdateBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
            .withDescription("description1")
            .withMetadata("BALANCE_0001")
            .withTotalValue(200)
            .withInitialValueStrategy("lottery")
            .withParameters([
                new Gs2Enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1001"),
                new Gs2Enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1002"),
                new Gs2Enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1003"),
                new Gs2Enchant.model.BalanceParameterValueModel()
                    .withName("parameter-1004"),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.update_balance_parameter_model_master(
        enchant.UpdateBalanceParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('balance-0001')
            .with_description('description1')
            .with_metadata('BALANCE_0001')
            .with_total_value(200)
            .with_initial_value_strategy('lottery')
            .with_parameters([
                enchant.BalanceParameterValueModel()
                    .with_name('parameter-1001'),
                enchant.BalanceParameterValueModel()
                    .with_name('parameter-1002'),
                enchant.BalanceParameterValueModel()
                    .with_name('parameter-1003'),
                enchant.BalanceParameterValueModel()
                    .with_name('parameter-1004'),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.update_balance_parameter_model_master({
    namespaceName="namespace1",
    parameterName="balance-0001",
    description="description1",
    metadata="BALANCE_0001",
    totalValue=200,
    initialValueStrategy="lottery",
    parameters={
        {
            name="parameter-1001",
        },
        {
            name="parameter-1002",
        },
        {
            name="parameter-1003",
        },
        {
            name="parameter-1004",
        }
    },
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.update_balance_parameter_model_master_async({
    namespaceName="namespace1",
    parameterName="balance-0001",
    description="description1",
    metadata="BALANCE_0001",
    totalValue=200,
    initialValueStrategy="lottery",
    parameters={
        {
            name="parameter-1001",
        },
        {
            name="parameter-1002",
        },
        {
            name="parameter-1003",
        },
        {
            name="parameter-1004",
        }
    },
})

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

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

result = api_result.result
item = result.item;

deleteBalanceParameterModelMaster

Delete Balance Parameter Model Master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Balance parameter model name

Result

	Type	Description
item	BalanceParameterModelMaster	Deleted Balance Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DeleteBalanceParameterModelMaster(
    &enchant.DeleteBalanceParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("balance-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DeleteBalanceParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteBalanceParameterModelMaster(
        (new DeleteBalanceParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("balance-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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DeleteBalanceParameterModelMasterRequest;
import io.gs2.enchant.result.DeleteBalanceParameterModelMasterResult;

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

try {
    DeleteBalanceParameterModelMasterResult result = client.deleteBalanceParameterModelMaster(
        new DeleteBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
    );
    BalanceParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DeleteBalanceParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.DeleteBalanceParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DeleteBalanceParameterModelMasterResult> asyncResult = null;
yield return client.DeleteBalanceParameterModelMaster(
    new Gs2.Gs2Enchant.Request.DeleteBalanceParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("balance-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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.deleteBalanceParameterModelMaster(
        new Gs2Enchant.DeleteBalanceParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.delete_balance_parameter_model_master(
        enchant.DeleteBalanceParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('balance-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.delete_balance_parameter_model_master({
    namespaceName="namespace1",
    parameterName="balance-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.delete_balance_parameter_model_master_async({
    namespaceName="namespace1",
    parameterName="balance-0001",
})

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

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

result = api_result.result
item = result.item;

describeRarityParameterModels

Get list of Rarity Parameter Models

Request

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

Result

	Type	Description
items	List<RarityParameterModel>	List of Rarity Parameter Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeRarityParameterModels(
    &enchant.DescribeRarityParameterModelsRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeRarityParameterModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeRarityParameterModels(
        (new DescribeRarityParameterModelsRequest())
            ->withNamespaceName(self::namespace1)
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeRarityParameterModelsRequest;
import io.gs2.enchant.result.DescribeRarityParameterModelsResult;

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

try {
    DescribeRarityParameterModelsResult result = client.describeRarityParameterModels(
        new DescribeRarityParameterModelsRequest()
            .withNamespaceName("namespace1")
    );
    List<RarityParameterModel> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeRarityParameterModelsRequest;
using Gs2.Gs2Enchant.Result.DescribeRarityParameterModelsResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeRarityParameterModelsResult> asyncResult = null;
yield return client.DescribeRarityParameterModels(
    new Gs2.Gs2Enchant.Request.DescribeRarityParameterModelsRequest()
        .WithNamespaceName("namespace1"),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeRarityParameterModels(
        new Gs2Enchant.DescribeRarityParameterModelsRequest()
            .withNamespaceName("namespace1")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.describe_rarity_parameter_models(
        enchant.DescribeRarityParameterModelsRequest()
            .with_namespace_name(self.hash1)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.describe_rarity_parameter_models({
    namespaceName="namespace1",
})

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

result = api_result.result
items = result.items;

client = gs2('enchant')

api_result_handler = client.describe_rarity_parameter_models_async({
    namespaceName="namespace1",
})

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

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

result = api_result.result
items = result.items;

getRarityParameterModel

Get Rarity Parameter Model

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Balance parameter model name

Result

	Type	Description
item	RarityParameterModel	Rarity Parameter Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetRarityParameterModel(
    &enchant.GetRarityParameterModelRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("rarity-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetRarityParameterModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getRarityParameterModel(
        (new GetRarityParameterModelRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("rarity-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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetRarityParameterModelRequest;
import io.gs2.enchant.result.GetRarityParameterModelResult;

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

try {
    GetRarityParameterModelResult result = client.getRarityParameterModel(
        new GetRarityParameterModelRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
    );
    RarityParameterModel 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetRarityParameterModelRequest;
using Gs2.Gs2Enchant.Result.GetRarityParameterModelResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetRarityParameterModelResult> asyncResult = null;
yield return client.GetRarityParameterModel(
    new Gs2.Gs2Enchant.Request.GetRarityParameterModelRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("rarity-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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getRarityParameterModel(
        new Gs2Enchant.GetRarityParameterModelRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_rarity_parameter_model(
        enchant.GetRarityParameterModelRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('rarity-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_rarity_parameter_model({
    namespaceName="namespace1",
    parameterName="rarity-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_rarity_parameter_model_async({
    namespaceName="namespace1",
    parameterName="rarity-0001",
})

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

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

result = api_result.result
item = result.item;

describeRarityParameterModelMasters

Get list of Rarity Parameter Model Masters

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 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<RarityParameterModelMaster>	List of Rarity Parameter Model Master
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeRarityParameterModelMasters(
    &enchant.DescribeRarityParameterModelMastersRequest {
        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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeRarityParameterModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeRarityParameterModelMasters(
        (new DescribeRarityParameterModelMastersRequest())
            ->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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeRarityParameterModelMastersRequest;
import io.gs2.enchant.result.DescribeRarityParameterModelMastersResult;

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

try {
    DescribeRarityParameterModelMastersResult result = client.describeRarityParameterModelMasters(
        new DescribeRarityParameterModelMastersRequest()
            .withNamespaceName("namespace1")
            .withPageToken(null)
            .withLimit(null)
    );
    List<RarityParameterModelMaster> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeRarityParameterModelMastersRequest;
using Gs2.Gs2Enchant.Result.DescribeRarityParameterModelMastersResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeRarityParameterModelMastersResult> asyncResult = null;
yield return client.DescribeRarityParameterModelMasters(
    new Gs2.Gs2Enchant.Request.DescribeRarityParameterModelMastersRequest()
        .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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeRarityParameterModelMasters(
        new Gs2Enchant.DescribeRarityParameterModelMastersRequest()
            .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 enchant

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

try:
    result = client.describe_rarity_parameter_model_masters(
        enchant.DescribeRarityParameterModelMastersRequest()
            .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('enchant')

api_result = client.describe_rarity_parameter_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;

client = gs2('enchant')

api_result_handler = client.describe_rarity_parameter_model_masters_async({
    namespaceName="namespace1",
    pageToken=nil,
    limit=nil,
})

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

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

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

createRarityParameterModelMaster

Create a new Rarity Parameter Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
name	string	✓	~ 128 chars	Rarity parameter model name
description	string		~ 1024 chars	Description
metadata	string		~ 2048 chars	metadata
maximumParameterCount	int	✓	1 ~ 10	Maximum number of parameters to be given
parameterCounts	List<RarityParameterCountModel>	✓	1 ~ 10 items	Rarity parameter value model list
parameters	List<RarityParameterValueModel>	✓	1 ~ 1000 items	Rarity parameter value model list

Result

	Type	Description
item	RarityParameterModelMaster	Created Rarity Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.CreateRarityParameterModelMaster(
    &enchant.CreateRarityParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        Name: pointy.String("rarity-0001"),
        Description: nil,
        Metadata: nil,
        MaximumParameterCount: pointy.Int32(5),
        ParameterCounts: []enchant.RarityParameterCountModel{
            enchant.RarityParameterCountModel{
                Count: pointy.Int32(0),
                Weight: pointy.Int32(1),
            },
            enchant.RarityParameterCountModel{
                Count: pointy.Int32(1),
                Weight: pointy.Int32(2),
            },
            enchant.RarityParameterCountModel{
                Count: pointy.Int32(2),
                Weight: pointy.Int32(3),
            },
        },
        Parameters: []enchant.RarityParameterValueModel{
            enchant.RarityParameterValueModel{
                Name: pointy.String("parameter-0001"),
                ResourceName: pointy.String("resource-0001"),
                ResourceValue: pointy.Int64(100),
                Weight: pointy.Int32(1),
            },
            enchant.RarityParameterValueModel{
                Name: pointy.String("parameter-0002"),
                ResourceName: pointy.String("resource-0002"),
                ResourceValue: pointy.Int64(200),
                Weight: pointy.Int32(2),
            },
            enchant.RarityParameterValueModel{
                Name: pointy.String("parameter-0003"),
                ResourceName: pointy.String("resource-0003"),
                ResourceValue: pointy.Int64(300),
                Weight: pointy.Int32(3),
            },
        },
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\CreateRarityParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createRarityParameterModelMaster(
        (new CreateRarityParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withName("rarity-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withMaximumParameterCount(5)
            ->withParameterCounts([
                (new \Gs2\Enchant\Model\RarityParameterCountModel())
                    ->withCount(0)
                    ->withWeight(1),
                (new \Gs2\Enchant\Model\RarityParameterCountModel())
                    ->withCount(1)
                    ->withWeight(2),
                (new \Gs2\Enchant\Model\RarityParameterCountModel())
                    ->withCount(2)
                    ->withWeight(3),
            ])
            ->withParameters([
                (new \Gs2\Enchant\Model\RarityParameterValueModel())
                    ->withName("parameter-0001")
                    ->withResourceName("resource-0001")
                    ->withResourceValue(100)
                    ->withWeight(1),
                (new \Gs2\Enchant\Model\RarityParameterValueModel())
                    ->withName("parameter-0002")
                    ->withResourceName("resource-0002")
                    ->withResourceValue(200)
                    ->withWeight(2),
                (new \Gs2\Enchant\Model\RarityParameterValueModel())
                    ->withName("parameter-0003")
                    ->withResourceName("resource-0003")
                    ->withResourceValue(300)
                    ->withWeight(3),
            ])
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.CreateRarityParameterModelMasterRequest;
import io.gs2.enchant.result.CreateRarityParameterModelMasterResult;

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

try {
    CreateRarityParameterModelMasterResult result = client.createRarityParameterModelMaster(
        new CreateRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withName("rarity-0001")
            .withDescription(null)
            .withMetadata(null)
            .withMaximumParameterCount(5)
            .withParameterCounts(Arrays.asList(
                new io.gs2.enchant.model.RarityParameterCountModel()
                    .withCount(0)
                    .withWeight(1),
                new io.gs2.enchant.model.RarityParameterCountModel()
                    .withCount(1)
                    .withWeight(2),
                new io.gs2.enchant.model.RarityParameterCountModel()
                    .withCount(2)
                    .withWeight(3)
            ))
            .withParameters(Arrays.asList(
                new io.gs2.enchant.model.RarityParameterValueModel()
                    .withName("parameter-0001")
                    .withResourceName("resource-0001")
                    .withResourceValue(100L)
                    .withWeight(1),
                new io.gs2.enchant.model.RarityParameterValueModel()
                    .withName("parameter-0002")
                    .withResourceName("resource-0002")
                    .withResourceValue(200L)
                    .withWeight(2),
                new io.gs2.enchant.model.RarityParameterValueModel()
                    .withName("parameter-0003")
                    .withResourceName("resource-0003")
                    .withResourceValue(300L)
                    .withWeight(3)
            ))
    );
    RarityParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.CreateRarityParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.CreateRarityParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.CreateRarityParameterModelMasterResult> asyncResult = null;
yield return client.CreateRarityParameterModelMaster(
    new Gs2.Gs2Enchant.Request.CreateRarityParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithName("rarity-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithMaximumParameterCount(5)
        .WithParameterCounts(new Gs2.Gs2Enchant.Model.RarityParameterCountModel[] {
            new Gs2.Gs2Enchant.Model.RarityParameterCountModel()
                .WithCount(0)
                .WithWeight(1),
            new Gs2.Gs2Enchant.Model.RarityParameterCountModel()
                .WithCount(1)
                .WithWeight(2),
            new Gs2.Gs2Enchant.Model.RarityParameterCountModel()
                .WithCount(2)
                .WithWeight(3),
        })
        .WithParameters(new Gs2.Gs2Enchant.Model.RarityParameterValueModel[] {
            new Gs2.Gs2Enchant.Model.RarityParameterValueModel()
                .WithName("parameter-0001")
                .WithResourceName("resource-0001")
                .WithResourceValue(100L)
                .WithWeight(1),
            new Gs2.Gs2Enchant.Model.RarityParameterValueModel()
                .WithName("parameter-0002")
                .WithResourceName("resource-0002")
                .WithResourceValue(200L)
                .WithWeight(2),
            new Gs2.Gs2Enchant.Model.RarityParameterValueModel()
                .WithName("parameter-0003")
                .WithResourceName("resource-0003")
                .WithResourceValue(300L)
                .WithWeight(3),
        }),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.createRarityParameterModelMaster(
        new Gs2Enchant.CreateRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withName("rarity-0001")
            .withDescription(null)
            .withMetadata(null)
            .withMaximumParameterCount(5)
            .withParameterCounts([
                new Gs2Enchant.model.RarityParameterCountModel()
                    .withCount(0)
                    .withWeight(1),
                new Gs2Enchant.model.RarityParameterCountModel()
                    .withCount(1)
                    .withWeight(2),
                new Gs2Enchant.model.RarityParameterCountModel()
                    .withCount(2)
                    .withWeight(3),
            ])
            .withParameters([
                new Gs2Enchant.model.RarityParameterValueModel()
                    .withName("parameter-0001")
                    .withResourceName("resource-0001")
                    .withResourceValue(100)
                    .withWeight(1),
                new Gs2Enchant.model.RarityParameterValueModel()
                    .withName("parameter-0002")
                    .withResourceName("resource-0002")
                    .withResourceValue(200)
                    .withWeight(2),
                new Gs2Enchant.model.RarityParameterValueModel()
                    .withName("parameter-0003")
                    .withResourceName("resource-0003")
                    .withResourceValue(300)
                    .withWeight(3),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.create_rarity_parameter_model_master(
        enchant.CreateRarityParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_name('rarity-0001')
            .with_description(None)
            .with_metadata(None)
            .with_maximum_parameter_count(5)
            .with_parameter_counts([
                enchant.RarityParameterCountModel()
                    .with_count(0)
                    .with_weight(1),
                enchant.RarityParameterCountModel()
                    .with_count(1)
                    .with_weight(2),
                enchant.RarityParameterCountModel()
                    .with_count(2)
                    .with_weight(3),
            ])
            .with_parameters([
                enchant.RarityParameterValueModel()
                    .with_name('parameter-0001')
                    .with_resource_name('resource-0001')
                    .with_resource_value(100)
                    .with_weight(1),
                enchant.RarityParameterValueModel()
                    .with_name('parameter-0002')
                    .with_resource_name('resource-0002')
                    .with_resource_value(200)
                    .with_weight(2),
                enchant.RarityParameterValueModel()
                    .with_name('parameter-0003')
                    .with_resource_name('resource-0003')
                    .with_resource_value(300)
                    .with_weight(3),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.create_rarity_parameter_model_master({
    namespaceName="namespace1",
    name="rarity-0001",
    description=nil,
    metadata=nil,
    maximumParameterCount=5,
    parameterCounts={
        {
            count=0,
            weight=1,
        },
        {
            count=1,
            weight=2,
        },
        {
            count=2,
            weight=3,
        }
    },
    parameters={
        {
            name="parameter-0001",
            resourceName="resource-0001",
            resourceValue=100,
            weight=1,
        },
        {
            name="parameter-0002",
            resourceName="resource-0002",
            resourceValue=200,
            weight=2,
        },
        {
            name="parameter-0003",
            resourceName="resource-0003",
            resourceValue=300,
            weight=3,
        }
    },
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.create_rarity_parameter_model_master_async({
    namespaceName="namespace1",
    name="rarity-0001",
    description=nil,
    metadata=nil,
    maximumParameterCount=5,
    parameterCounts={
        {
            count=0,
            weight=1,
        },
        {
            count=1,
            weight=2,
        },
        {
            count=2,
            weight=3,
        }
    },
    parameters={
        {
            name="parameter-0001",
            resourceName="resource-0001",
            resourceValue=100,
            weight=1,
        },
        {
            name="parameter-0002",
            resourceName="resource-0002",
            resourceValue=200,
            weight=2,
        },
        {
            name="parameter-0003",
            resourceName="resource-0003",
            resourceValue=300,
            weight=3,
        }
    },
})

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

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

result = api_result.result
item = result.item;

getRarityParameterModelMaster

Get Rarity Parameter Model Master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Rarity parameter model name

Result

	Type	Description
item	RarityParameterModelMaster	Rarity Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetRarityParameterModelMaster(
    &enchant.GetRarityParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("rarity-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetRarityParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getRarityParameterModelMaster(
        (new GetRarityParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("rarity-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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetRarityParameterModelMasterRequest;
import io.gs2.enchant.result.GetRarityParameterModelMasterResult;

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

try {
    GetRarityParameterModelMasterResult result = client.getRarityParameterModelMaster(
        new GetRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
    );
    RarityParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetRarityParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.GetRarityParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetRarityParameterModelMasterResult> asyncResult = null;
yield return client.GetRarityParameterModelMaster(
    new Gs2.Gs2Enchant.Request.GetRarityParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("rarity-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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getRarityParameterModelMaster(
        new Gs2Enchant.GetRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_rarity_parameter_model_master(
        enchant.GetRarityParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('rarity-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_rarity_parameter_model_master({
    namespaceName="namespace1",
    parameterName="rarity-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_rarity_parameter_model_master_async({
    namespaceName="namespace1",
    parameterName="rarity-0001",
})

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

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

result = api_result.result
item = result.item;

updateRarityParameterModelMaster

Update Rarity Parameter Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
parameterName	string	✓	~ 128 chars	Rarity parameter model name
description	string		~ 1024 chars	Description
metadata	string		~ 2048 chars	metadata
maximumParameterCount	int	✓	1 ~ 10	Maximum number of parameters to be given
parameterCounts	List<RarityParameterCountModel>	✓	1 ~ 10 items	Rarity parameter value model list
parameters	List<RarityParameterValueModel>	✓	1 ~ 1000 items	Rarity parameter value model list

Result

	Type	Description
item	RarityParameterModelMaster	Updated Rarity Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.UpdateRarityParameterModelMaster(
    &enchant.UpdateRarityParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("rarity-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("RARITY_0001"),
        MaximumParameterCount: pointy.Int32(10),
        ParameterCounts: []enchant.RarityParameterCountModel{
            enchant.RarityParameterCountModel{
                Count: pointy.Int32(5),
                Weight: pointy.Int32(3),
            },
            enchant.RarityParameterCountModel{
                Count: pointy.Int32(10),
                Weight: pointy.Int32(5),
            },
            enchant.RarityParameterCountModel{
                Count: pointy.Int32(3),
                Weight: pointy.Int32(10),
            },
        },
        Parameters: []enchant.RarityParameterValueModel{
            enchant.RarityParameterValueModel{
                Name: pointy.String("parameter-1001"),
                ResourceName: pointy.String("resource-1001"),
                ResourceValue: pointy.Int64(10),
                Weight: pointy.Int32(10),
            },
            enchant.RarityParameterValueModel{
                Name: pointy.String("parameter-1002"),
                ResourceName: pointy.String("resource-1002"),
                ResourceValue: pointy.Int64(20),
                Weight: pointy.Int32(20),
            },
            enchant.RarityParameterValueModel{
                Name: pointy.String("parameter-1003"),
                ResourceName: pointy.String("resource-1003"),
                ResourceValue: pointy.Int64(30),
                Weight: pointy.Int32(30),
            },
            enchant.RarityParameterValueModel{
                Name: pointy.String("parameter-1004"),
                ResourceName: pointy.String("resource-1004"),
                ResourceValue: pointy.Int64(40),
                Weight: pointy.Int32(40),
            },
        },
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\UpdateRarityParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateRarityParameterModelMaster(
        (new UpdateRarityParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("rarity-0001")
            ->withDescription("description1")
            ->withMetadata("RARITY_0001")
            ->withMaximumParameterCount(10)
            ->withParameterCounts([
                (new \Gs2\Enchant\Model\RarityParameterCountModel())
                    ->withCount(5)
                    ->withWeight(3),
                (new \Gs2\Enchant\Model\RarityParameterCountModel())
                    ->withCount(10)
                    ->withWeight(5),
                (new \Gs2\Enchant\Model\RarityParameterCountModel())
                    ->withCount(3)
                    ->withWeight(10),
            ])
            ->withParameters([
                (new \Gs2\Enchant\Model\RarityParameterValueModel())
                    ->withName("parameter-1001")
                    ->withResourceName("resource-1001")
                    ->withResourceValue(10)
                    ->withWeight(10),
                (new \Gs2\Enchant\Model\RarityParameterValueModel())
                    ->withName("parameter-1002")
                    ->withResourceName("resource-1002")
                    ->withResourceValue(20)
                    ->withWeight(20),
                (new \Gs2\Enchant\Model\RarityParameterValueModel())
                    ->withName("parameter-1003")
                    ->withResourceName("resource-1003")
                    ->withResourceValue(30)
                    ->withWeight(30),
                (new \Gs2\Enchant\Model\RarityParameterValueModel())
                    ->withName("parameter-1004")
                    ->withResourceName("resource-1004")
                    ->withResourceValue(40)
                    ->withWeight(40),
            ])
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.UpdateRarityParameterModelMasterRequest;
import io.gs2.enchant.result.UpdateRarityParameterModelMasterResult;

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

try {
    UpdateRarityParameterModelMasterResult result = client.updateRarityParameterModelMaster(
        new UpdateRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
            .withDescription("description1")
            .withMetadata("RARITY_0001")
            .withMaximumParameterCount(10)
            .withParameterCounts(Arrays.asList(
                new io.gs2.enchant.model.RarityParameterCountModel()
                    .withCount(5)
                    .withWeight(3),
                new io.gs2.enchant.model.RarityParameterCountModel()
                    .withCount(10)
                    .withWeight(5),
                new io.gs2.enchant.model.RarityParameterCountModel()
                    .withCount(3)
                    .withWeight(10)
            ))
            .withParameters(Arrays.asList(
                new io.gs2.enchant.model.RarityParameterValueModel()
                    .withName("parameter-1001")
                    .withResourceName("resource-1001")
                    .withResourceValue(10L)
                    .withWeight(10),
                new io.gs2.enchant.model.RarityParameterValueModel()
                    .withName("parameter-1002")
                    .withResourceName("resource-1002")
                    .withResourceValue(20L)
                    .withWeight(20),
                new io.gs2.enchant.model.RarityParameterValueModel()
                    .withName("parameter-1003")
                    .withResourceName("resource-1003")
                    .withResourceValue(30L)
                    .withWeight(30),
                new io.gs2.enchant.model.RarityParameterValueModel()
                    .withName("parameter-1004")
                    .withResourceName("resource-1004")
                    .withResourceValue(40L)
                    .withWeight(40)
            ))
    );
    RarityParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.UpdateRarityParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.UpdateRarityParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.UpdateRarityParameterModelMasterResult> asyncResult = null;
yield return client.UpdateRarityParameterModelMaster(
    new Gs2.Gs2Enchant.Request.UpdateRarityParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("rarity-0001")
        .WithDescription("description1")
        .WithMetadata("RARITY_0001")
        .WithMaximumParameterCount(10)
        .WithParameterCounts(new Gs2.Gs2Enchant.Model.RarityParameterCountModel[] {
            new Gs2.Gs2Enchant.Model.RarityParameterCountModel()
                .WithCount(5)
                .WithWeight(3),
            new Gs2.Gs2Enchant.Model.RarityParameterCountModel()
                .WithCount(10)
                .WithWeight(5),
            new Gs2.Gs2Enchant.Model.RarityParameterCountModel()
                .WithCount(3)
                .WithWeight(10),
        })
        .WithParameters(new Gs2.Gs2Enchant.Model.RarityParameterValueModel[] {
            new Gs2.Gs2Enchant.Model.RarityParameterValueModel()
                .WithName("parameter-1001")
                .WithResourceName("resource-1001")
                .WithResourceValue(10L)
                .WithWeight(10),
            new Gs2.Gs2Enchant.Model.RarityParameterValueModel()
                .WithName("parameter-1002")
                .WithResourceName("resource-1002")
                .WithResourceValue(20L)
                .WithWeight(20),
            new Gs2.Gs2Enchant.Model.RarityParameterValueModel()
                .WithName("parameter-1003")
                .WithResourceName("resource-1003")
                .WithResourceValue(30L)
                .WithWeight(30),
            new Gs2.Gs2Enchant.Model.RarityParameterValueModel()
                .WithName("parameter-1004")
                .WithResourceName("resource-1004")
                .WithResourceValue(40L)
                .WithWeight(40),
        }),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.updateRarityParameterModelMaster(
        new Gs2Enchant.UpdateRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
            .withDescription("description1")
            .withMetadata("RARITY_0001")
            .withMaximumParameterCount(10)
            .withParameterCounts([
                new Gs2Enchant.model.RarityParameterCountModel()
                    .withCount(5)
                    .withWeight(3),
                new Gs2Enchant.model.RarityParameterCountModel()
                    .withCount(10)
                    .withWeight(5),
                new Gs2Enchant.model.RarityParameterCountModel()
                    .withCount(3)
                    .withWeight(10),
            ])
            .withParameters([
                new Gs2Enchant.model.RarityParameterValueModel()
                    .withName("parameter-1001")
                    .withResourceName("resource-1001")
                    .withResourceValue(10)
                    .withWeight(10),
                new Gs2Enchant.model.RarityParameterValueModel()
                    .withName("parameter-1002")
                    .withResourceName("resource-1002")
                    .withResourceValue(20)
                    .withWeight(20),
                new Gs2Enchant.model.RarityParameterValueModel()
                    .withName("parameter-1003")
                    .withResourceName("resource-1003")
                    .withResourceValue(30)
                    .withWeight(30),
                new Gs2Enchant.model.RarityParameterValueModel()
                    .withName("parameter-1004")
                    .withResourceName("resource-1004")
                    .withResourceValue(40)
                    .withWeight(40),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.update_rarity_parameter_model_master(
        enchant.UpdateRarityParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('rarity-0001')
            .with_description('description1')
            .with_metadata('RARITY_0001')
            .with_maximum_parameter_count(10)
            .with_parameter_counts([
                enchant.RarityParameterCountModel()
                    .with_count(5)
                    .with_weight(3),
                enchant.RarityParameterCountModel()
                    .with_count(10)
                    .with_weight(5),
                enchant.RarityParameterCountModel()
                    .with_count(3)
                    .with_weight(10),
            ])
            .with_parameters([
                enchant.RarityParameterValueModel()
                    .with_name('parameter-1001')
                    .with_resource_name('resource-1001')
                    .with_resource_value(10)
                    .with_weight(10),
                enchant.RarityParameterValueModel()
                    .with_name('parameter-1002')
                    .with_resource_name('resource-1002')
                    .with_resource_value(20)
                    .with_weight(20),
                enchant.RarityParameterValueModel()
                    .with_name('parameter-1003')
                    .with_resource_name('resource-1003')
                    .with_resource_value(30)
                    .with_weight(30),
                enchant.RarityParameterValueModel()
                    .with_name('parameter-1004')
                    .with_resource_name('resource-1004')
                    .with_resource_value(40)
                    .with_weight(40),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.update_rarity_parameter_model_master({
    namespaceName="namespace1",
    parameterName="rarity-0001",
    description="description1",
    metadata="RARITY_0001",
    maximumParameterCount=10,
    parameterCounts={
        {
            count=5,
            weight=3,
        },
        {
            count=10,
            weight=5,
        },
        {
            count=3,
            weight=10,
        }
    },
    parameters={
        {
            name="parameter-1001",
            resourceName="resource-1001",
            resourceValue=10,
            weight=10,
        },
        {
            name="parameter-1002",
            resourceName="resource-1002",
            resourceValue=20,
            weight=20,
        },
        {
            name="parameter-1003",
            resourceName="resource-1003",
            resourceValue=30,
            weight=30,
        },
        {
            name="parameter-1004",
            resourceName="resource-1004",
            resourceValue=40,
            weight=40,
        }
    },
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.update_rarity_parameter_model_master_async({
    namespaceName="namespace1",
    parameterName="rarity-0001",
    description="description1",
    metadata="RARITY_0001",
    maximumParameterCount=10,
    parameterCounts={
        {
            count=5,
            weight=3,
        },
        {
            count=10,
            weight=5,
        },
        {
            count=3,
            weight=10,
        }
    },
    parameters={
        {
            name="parameter-1001",
            resourceName="resource-1001",
            resourceValue=10,
            weight=10,
        },
        {
            name="parameter-1002",
            resourceName="resource-1002",
            resourceValue=20,
            weight=20,
        },
        {
            name="parameter-1003",
            resourceName="resource-1003",
            resourceValue=30,
            weight=30,
        },
        {
            name="parameter-1004",
            resourceName="resource-1004",
            resourceValue=40,
            weight=40,
        }
    },
})

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

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

result = api_result.result
item = result.item;

deleteRarityParameterModelMaster

Delete Rarity Parameter Model Master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Rarity parameter model name

Result

	Type	Description
item	RarityParameterModelMaster	Deleted Rarity Parameter Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DeleteRarityParameterModelMaster(
    &enchant.DeleteRarityParameterModelMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("rarity-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DeleteRarityParameterModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteRarityParameterModelMaster(
        (new DeleteRarityParameterModelMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("rarity-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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DeleteRarityParameterModelMasterRequest;
import io.gs2.enchant.result.DeleteRarityParameterModelMasterResult;

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

try {
    DeleteRarityParameterModelMasterResult result = client.deleteRarityParameterModelMaster(
        new DeleteRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
    );
    RarityParameterModelMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DeleteRarityParameterModelMasterRequest;
using Gs2.Gs2Enchant.Result.DeleteRarityParameterModelMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DeleteRarityParameterModelMasterResult> asyncResult = null;
yield return client.DeleteRarityParameterModelMaster(
    new Gs2.Gs2Enchant.Request.DeleteRarityParameterModelMasterRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("rarity-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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.deleteRarityParameterModelMaster(
        new Gs2Enchant.DeleteRarityParameterModelMasterRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.delete_rarity_parameter_model_master(
        enchant.DeleteRarityParameterModelMasterRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('rarity-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.delete_rarity_parameter_model_master({
    namespaceName="namespace1",
    parameterName="rarity-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.delete_rarity_parameter_model_master_async({
    namespaceName="namespace1",
    parameterName="rarity-0001",
})

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

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

result = api_result.result
item = result.item;

exportMaster

Export master data for currently available parameter settings

Request

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

Result

	Type	Description
item	CurrentParameterMaster	Currently Available Enhanced rate setting

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.ExportMaster(
    &enchant.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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.ExportMasterRequest;
import io.gs2.enchant.result.ExportMasterResult;

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

try {
    ExportMasterResult result = client.exportMaster(
        new ExportMasterRequest()
            .withNamespaceName("namespace1")
    );
    CurrentParameterMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.ExportMasterRequest;
using Gs2.Gs2Enchant.Result.ExportMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.ExportMasterResult> asyncResult = null;
yield return client.ExportMaster(
    new Gs2.Gs2Enchant.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 Gs2Enchant from '@/gs2/enchant';

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

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

from gs2 import core
from gs2 import enchant

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

try:
    result = client.export_master(
        enchant.ExportMasterRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

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;

client = gs2('enchant')

api_result_handler = client.export_master_async({
    namespaceName="namespace1",
})

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

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

result = api_result.result
item = result.item;

getCurrentParameterMaster

Retrieves the currently available parameter setting

Request

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

Result

	Type	Description
item	CurrentParameterMaster	Currently Available parameter setting

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetCurrentParameterMaster(
    &enchant.GetCurrentParameterMasterRequest {
        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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetCurrentParameterMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getCurrentParameterMaster(
        (new GetCurrentParameterMasterRequest())
            ->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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetCurrentParameterMasterRequest;
import io.gs2.enchant.result.GetCurrentParameterMasterResult;

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

try {
    GetCurrentParameterMasterResult result = client.getCurrentParameterMaster(
        new GetCurrentParameterMasterRequest()
            .withNamespaceName("namespace1")
    );
    CurrentParameterMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetCurrentParameterMasterRequest;
using Gs2.Gs2Enchant.Result.GetCurrentParameterMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetCurrentParameterMasterResult> asyncResult = null;
yield return client.GetCurrentParameterMaster(
    new Gs2.Gs2Enchant.Request.GetCurrentParameterMasterRequest()
        .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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getCurrentParameterMaster(
        new Gs2Enchant.GetCurrentParameterMasterRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_current_parameter_master(
        enchant.GetCurrentParameterMasterRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_current_parameter_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;

client = gs2('enchant')

api_result_handler = client.get_current_parameter_master_async({
    namespaceName="namespace1",
})

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

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

result = api_result.result
item = result.item;

updateCurrentParameterMaster

Update the currently available parameter settings

Request

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

Result

	Type	Description
item	CurrentParameterMaster	Updated and currently available parameter settings

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentParameterMaster(
    &enchant.UpdateCurrentParameterMasterRequest {
        NamespaceName: pointy.String("namespace1"),
        Settings: pointy.String("{\"version\": \"2023-07-18\", \"balanceParameterModels\": [{\"name\": \"balance-0001\", \"metadata\": \"BALANCE_0001\", \"totalValue\": 100, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}]}, {\"name\": \"balance-0002\", \"metadata\": \"BALANCE_0002\", \"totalValue\": 200, \"initialValueStrategy\": \"lottery\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\"}]}, {\"name\": \"balance-0003\", \"metadata\": \"BALANCE_0003\", \"totalValue\": 500, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}]}], \"rarityParameterModels\": [{\"name\": \"rarity-0001\", \"metadata\": \"RARITY_0001\", \"maximumParameterCount\": 5, \"parameterCounts\": [{\"count\": 0, \"weight\": 1}, {\"count\": 1, \"weight\": 2}, {\"count\": 2, \"weight\": 3}], \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\", \"resourceName\": \"resource-0001\", \"resourceValue\": 10, \"weight\": 1}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\", \"resourceName\": \"resource-0002\", \"resourceValue\": 20, \"weight\": 2}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\", \"resourceName\": \"resource-0003\", \"resourceValue\": 30, \"weight\": 3}]}, {\"name\": \"rarity-0002\", \"metadata\": \"RARITY_0002\", \"maximumParameterCount\": 10, \"parameterCounts\": [{\"count\": 1, \"weight\": 10}, {\"count\": 2, \"weight\": 20}, {\"count\": 3, \"weight\": 30}], \"parameters\": [{\"name\": \"parameter-1001\", \"metadata\": \"PARAMETER_1001\", \"resourceName\": \"resource-1001\", \"resourceValue\": 100, \"weight\": 10}, {\"name\": \"parameter-1002\", \"metadata\": \"PARAMETER_1002\", \"resourceName\": \"resource-1002\", \"resourceValue\": 200, \"weight\": 20}, {\"name\": \"parameter-1003\", \"metadata\": \"PARAMETER_1003\", \"resourceName\": \"resource-1003\", \"resourceValue\": 300, \"weight\": 30}]}, {\"name\": \"rarity-0003\", \"metadata\": \"RARITY_0003\", \"maximumParameterCount\": 3, \"parameterCounts\": [{\"count\": 2, \"weight\": 5}, {\"count\": 3, \"weight\": 10}, {\"count\": 4, \"weight\": 15}], \"parameters\": [{\"name\": \"parameter-2001\", \"metadata\": \"PARAMETER_2001\", \"resourceName\": \"resource-2001\", \"resourceValue\": 1000, \"weight\": 2}, {\"name\": \"parameter-2002\", \"metadata\": \"PARAMETER_2002\", \"resourceName\": \"resource-2002\", \"resourceValue\": 2000, \"weight\": 4}, {\"name\": \"parameter-2003\", \"metadata\": \"PARAMETER_2003\", \"resourceName\": \"resource-2003\", \"resourceValue\": 3000, \"weight\": 6}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\", \"resourceName\": \"resource-2004\", \"resourceValue\": 4000, \"weight\": 8}]}]}"),
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\UpdateCurrentParameterMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentParameterMaster(
        (new UpdateCurrentParameterMasterRequest())
            ->withNamespaceName(self::namespace1)
            ->withSettings("{\"version\": \"2023-07-18\", \"balanceParameterModels\": [{\"name\": \"balance-0001\", \"metadata\": \"BALANCE_0001\", \"totalValue\": 100, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}]}, {\"name\": \"balance-0002\", \"metadata\": \"BALANCE_0002\", \"totalValue\": 200, \"initialValueStrategy\": \"lottery\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\"}]}, {\"name\": \"balance-0003\", \"metadata\": \"BALANCE_0003\", \"totalValue\": 500, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}]}], \"rarityParameterModels\": [{\"name\": \"rarity-0001\", \"metadata\": \"RARITY_0001\", \"maximumParameterCount\": 5, \"parameterCounts\": [{\"count\": 0, \"weight\": 1}, {\"count\": 1, \"weight\": 2}, {\"count\": 2, \"weight\": 3}], \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\", \"resourceName\": \"resource-0001\", \"resourceValue\": 10, \"weight\": 1}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\", \"resourceName\": \"resource-0002\", \"resourceValue\": 20, \"weight\": 2}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\", \"resourceName\": \"resource-0003\", \"resourceValue\": 30, \"weight\": 3}]}, {\"name\": \"rarity-0002\", \"metadata\": \"RARITY_0002\", \"maximumParameterCount\": 10, \"parameterCounts\": [{\"count\": 1, \"weight\": 10}, {\"count\": 2, \"weight\": 20}, {\"count\": 3, \"weight\": 30}], \"parameters\": [{\"name\": \"parameter-1001\", \"metadata\": \"PARAMETER_1001\", \"resourceName\": \"resource-1001\", \"resourceValue\": 100, \"weight\": 10}, {\"name\": \"parameter-1002\", \"metadata\": \"PARAMETER_1002\", \"resourceName\": \"resource-1002\", \"resourceValue\": 200, \"weight\": 20}, {\"name\": \"parameter-1003\", \"metadata\": \"PARAMETER_1003\", \"resourceName\": \"resource-1003\", \"resourceValue\": 300, \"weight\": 30}]}, {\"name\": \"rarity-0003\", \"metadata\": \"RARITY_0003\", \"maximumParameterCount\": 3, \"parameterCounts\": [{\"count\": 2, \"weight\": 5}, {\"count\": 3, \"weight\": 10}, {\"count\": 4, \"weight\": 15}], \"parameters\": [{\"name\": \"parameter-2001\", \"metadata\": \"PARAMETER_2001\", \"resourceName\": \"resource-2001\", \"resourceValue\": 1000, \"weight\": 2}, {\"name\": \"parameter-2002\", \"metadata\": \"PARAMETER_2002\", \"resourceName\": \"resource-2002\", \"resourceValue\": 2000, \"weight\": 4}, {\"name\": \"parameter-2003\", \"metadata\": \"PARAMETER_2003\", \"resourceName\": \"resource-2003\", \"resourceValue\": 3000, \"weight\": 6}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\", \"resourceName\": \"resource-2004\", \"resourceValue\": 4000, \"weight\": 8}]}]}")
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.UpdateCurrentParameterMasterRequest;
import io.gs2.enchant.result.UpdateCurrentParameterMasterResult;

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

try {
    UpdateCurrentParameterMasterResult result = client.updateCurrentParameterMaster(
        new UpdateCurrentParameterMasterRequest()
            .withNamespaceName("namespace1")
            .withSettings("{\"version\": \"2023-07-18\", \"balanceParameterModels\": [{\"name\": \"balance-0001\", \"metadata\": \"BALANCE_0001\", \"totalValue\": 100, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}]}, {\"name\": \"balance-0002\", \"metadata\": \"BALANCE_0002\", \"totalValue\": 200, \"initialValueStrategy\": \"lottery\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\"}]}, {\"name\": \"balance-0003\", \"metadata\": \"BALANCE_0003\", \"totalValue\": 500, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}]}], \"rarityParameterModels\": [{\"name\": \"rarity-0001\", \"metadata\": \"RARITY_0001\", \"maximumParameterCount\": 5, \"parameterCounts\": [{\"count\": 0, \"weight\": 1}, {\"count\": 1, \"weight\": 2}, {\"count\": 2, \"weight\": 3}], \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\", \"resourceName\": \"resource-0001\", \"resourceValue\": 10, \"weight\": 1}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\", \"resourceName\": \"resource-0002\", \"resourceValue\": 20, \"weight\": 2}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\", \"resourceName\": \"resource-0003\", \"resourceValue\": 30, \"weight\": 3}]}, {\"name\": \"rarity-0002\", \"metadata\": \"RARITY_0002\", \"maximumParameterCount\": 10, \"parameterCounts\": [{\"count\": 1, \"weight\": 10}, {\"count\": 2, \"weight\": 20}, {\"count\": 3, \"weight\": 30}], \"parameters\": [{\"name\": \"parameter-1001\", \"metadata\": \"PARAMETER_1001\", \"resourceName\": \"resource-1001\", \"resourceValue\": 100, \"weight\": 10}, {\"name\": \"parameter-1002\", \"metadata\": \"PARAMETER_1002\", \"resourceName\": \"resource-1002\", \"resourceValue\": 200, \"weight\": 20}, {\"name\": \"parameter-1003\", \"metadata\": \"PARAMETER_1003\", \"resourceName\": \"resource-1003\", \"resourceValue\": 300, \"weight\": 30}]}, {\"name\": \"rarity-0003\", \"metadata\": \"RARITY_0003\", \"maximumParameterCount\": 3, \"parameterCounts\": [{\"count\": 2, \"weight\": 5}, {\"count\": 3, \"weight\": 10}, {\"count\": 4, \"weight\": 15}], \"parameters\": [{\"name\": \"parameter-2001\", \"metadata\": \"PARAMETER_2001\", \"resourceName\": \"resource-2001\", \"resourceValue\": 1000, \"weight\": 2}, {\"name\": \"parameter-2002\", \"metadata\": \"PARAMETER_2002\", \"resourceName\": \"resource-2002\", \"resourceValue\": 2000, \"weight\": 4}, {\"name\": \"parameter-2003\", \"metadata\": \"PARAMETER_2003\", \"resourceName\": \"resource-2003\", \"resourceValue\": 3000, \"weight\": 6}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\", \"resourceName\": \"resource-2004\", \"resourceValue\": 4000, \"weight\": 8}]}]}")
    );
    CurrentParameterMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.UpdateCurrentParameterMasterRequest;
using Gs2.Gs2Enchant.Result.UpdateCurrentParameterMasterResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.UpdateCurrentParameterMasterResult> asyncResult = null;
yield return client.UpdateCurrentParameterMaster(
    new Gs2.Gs2Enchant.Request.UpdateCurrentParameterMasterRequest()
        .WithNamespaceName("namespace1")
        .WithSettings("{\"version\": \"2023-07-18\", \"balanceParameterModels\": [{\"name\": \"balance-0001\", \"metadata\": \"BALANCE_0001\", \"totalValue\": 100, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}]}, {\"name\": \"balance-0002\", \"metadata\": \"BALANCE_0002\", \"totalValue\": 200, \"initialValueStrategy\": \"lottery\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\"}]}, {\"name\": \"balance-0003\", \"metadata\": \"BALANCE_0003\", \"totalValue\": 500, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}]}], \"rarityParameterModels\": [{\"name\": \"rarity-0001\", \"metadata\": \"RARITY_0001\", \"maximumParameterCount\": 5, \"parameterCounts\": [{\"count\": 0, \"weight\": 1}, {\"count\": 1, \"weight\": 2}, {\"count\": 2, \"weight\": 3}], \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\", \"resourceName\": \"resource-0001\", \"resourceValue\": 10, \"weight\": 1}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\", \"resourceName\": \"resource-0002\", \"resourceValue\": 20, \"weight\": 2}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\", \"resourceName\": \"resource-0003\", \"resourceValue\": 30, \"weight\": 3}]}, {\"name\": \"rarity-0002\", \"metadata\": \"RARITY_0002\", \"maximumParameterCount\": 10, \"parameterCounts\": [{\"count\": 1, \"weight\": 10}, {\"count\": 2, \"weight\": 20}, {\"count\": 3, \"weight\": 30}], \"parameters\": [{\"name\": \"parameter-1001\", \"metadata\": \"PARAMETER_1001\", \"resourceName\": \"resource-1001\", \"resourceValue\": 100, \"weight\": 10}, {\"name\": \"parameter-1002\", \"metadata\": \"PARAMETER_1002\", \"resourceName\": \"resource-1002\", \"resourceValue\": 200, \"weight\": 20}, {\"name\": \"parameter-1003\", \"metadata\": \"PARAMETER_1003\", \"resourceName\": \"resource-1003\", \"resourceValue\": 300, \"weight\": 30}]}, {\"name\": \"rarity-0003\", \"metadata\": \"RARITY_0003\", \"maximumParameterCount\": 3, \"parameterCounts\": [{\"count\": 2, \"weight\": 5}, {\"count\": 3, \"weight\": 10}, {\"count\": 4, \"weight\": 15}], \"parameters\": [{\"name\": \"parameter-2001\", \"metadata\": \"PARAMETER_2001\", \"resourceName\": \"resource-2001\", \"resourceValue\": 1000, \"weight\": 2}, {\"name\": \"parameter-2002\", \"metadata\": \"PARAMETER_2002\", \"resourceName\": \"resource-2002\", \"resourceValue\": 2000, \"weight\": 4}, {\"name\": \"parameter-2003\", \"metadata\": \"PARAMETER_2003\", \"resourceName\": \"resource-2003\", \"resourceValue\": 3000, \"weight\": 6}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\", \"resourceName\": \"resource-2004\", \"resourceValue\": 4000, \"weight\": 8}]}]}"),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.updateCurrentParameterMaster(
        new Gs2Enchant.UpdateCurrentParameterMasterRequest()
            .withNamespaceName("namespace1")
            .withSettings("{\"version\": \"2023-07-18\", \"balanceParameterModels\": [{\"name\": \"balance-0001\", \"metadata\": \"BALANCE_0001\", \"totalValue\": 100, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}]}, {\"name\": \"balance-0002\", \"metadata\": \"BALANCE_0002\", \"totalValue\": 200, \"initialValueStrategy\": \"lottery\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\"}]}, {\"name\": \"balance-0003\", \"metadata\": \"BALANCE_0003\", \"totalValue\": 500, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}]}], \"rarityParameterModels\": [{\"name\": \"rarity-0001\", \"metadata\": \"RARITY_0001\", \"maximumParameterCount\": 5, \"parameterCounts\": [{\"count\": 0, \"weight\": 1}, {\"count\": 1, \"weight\": 2}, {\"count\": 2, \"weight\": 3}], \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\", \"resourceName\": \"resource-0001\", \"resourceValue\": 10, \"weight\": 1}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\", \"resourceName\": \"resource-0002\", \"resourceValue\": 20, \"weight\": 2}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\", \"resourceName\": \"resource-0003\", \"resourceValue\": 30, \"weight\": 3}]}, {\"name\": \"rarity-0002\", \"metadata\": \"RARITY_0002\", \"maximumParameterCount\": 10, \"parameterCounts\": [{\"count\": 1, \"weight\": 10}, {\"count\": 2, \"weight\": 20}, {\"count\": 3, \"weight\": 30}], \"parameters\": [{\"name\": \"parameter-1001\", \"metadata\": \"PARAMETER_1001\", \"resourceName\": \"resource-1001\", \"resourceValue\": 100, \"weight\": 10}, {\"name\": \"parameter-1002\", \"metadata\": \"PARAMETER_1002\", \"resourceName\": \"resource-1002\", \"resourceValue\": 200, \"weight\": 20}, {\"name\": \"parameter-1003\", \"metadata\": \"PARAMETER_1003\", \"resourceName\": \"resource-1003\", \"resourceValue\": 300, \"weight\": 30}]}, {\"name\": \"rarity-0003\", \"metadata\": \"RARITY_0003\", \"maximumParameterCount\": 3, \"parameterCounts\": [{\"count\": 2, \"weight\": 5}, {\"count\": 3, \"weight\": 10}, {\"count\": 4, \"weight\": 15}], \"parameters\": [{\"name\": \"parameter-2001\", \"metadata\": \"PARAMETER_2001\", \"resourceName\": \"resource-2001\", \"resourceValue\": 1000, \"weight\": 2}, {\"name\": \"parameter-2002\", \"metadata\": \"PARAMETER_2002\", \"resourceName\": \"resource-2002\", \"resourceValue\": 2000, \"weight\": 4}, {\"name\": \"parameter-2003\", \"metadata\": \"PARAMETER_2003\", \"resourceName\": \"resource-2003\", \"resourceValue\": 3000, \"weight\": 6}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\", \"resourceName\": \"resource-2004\", \"resourceValue\": 4000, \"weight\": 8}]}]}")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.update_current_parameter_master(
        enchant.UpdateCurrentParameterMasterRequest()
            .with_namespace_name(self.hash1)
            .with_settings('{"version": "2023-07-18", "balanceParameterModels": [{"name": "balance-0001", "metadata": "BALANCE_0001", "totalValue": 100, "initialValueStrategy": "average", "parameters": [{"name": "parameter-0001", "metadata": "PARAMETER_0001"}, {"name": "parameter-0002", "metadata": "PARAMETER_0002"}, {"name": "parameter-0003", "metadata": "PARAMETER_0003"}]}, {"name": "balance-0002", "metadata": "BALANCE_0002", "totalValue": 200, "initialValueStrategy": "lottery", "parameters": [{"name": "parameter-0001", "metadata": "PARAMETER_0001"}, {"name": "parameter-0002", "metadata": "PARAMETER_0002"}, {"name": "parameter-0003", "metadata": "PARAMETER_0003"}, {"name": "parameter-0004", "metadata": "PARAMETER_0004"}]}, {"name": "balance-0003", "metadata": "BALANCE_0003", "totalValue": 500, "initialValueStrategy": "average", "parameters": [{"name": "parameter-0001", "metadata": "PARAMETER_0001"}, {"name": "parameter-0002", "metadata": "PARAMETER_0002"}]}], "rarityParameterModels": [{"name": "rarity-0001", "metadata": "RARITY_0001", "maximumParameterCount": 5, "parameterCounts": [{"count": 0, "weight": 1}, {"count": 1, "weight": 2}, {"count": 2, "weight": 3}], "parameters": [{"name": "parameter-0001", "metadata": "PARAMETER_0001", "resourceName": "resource-0001", "resourceValue": 10, "weight": 1}, {"name": "parameter-0002", "metadata": "PARAMETER_0002", "resourceName": "resource-0002", "resourceValue": 20, "weight": 2}, {"name": "parameter-0003", "metadata": "PARAMETER_0003", "resourceName": "resource-0003", "resourceValue": 30, "weight": 3}]}, {"name": "rarity-0002", "metadata": "RARITY_0002", "maximumParameterCount": 10, "parameterCounts": [{"count": 1, "weight": 10}, {"count": 2, "weight": 20}, {"count": 3, "weight": 30}], "parameters": [{"name": "parameter-1001", "metadata": "PARAMETER_1001", "resourceName": "resource-1001", "resourceValue": 100, "weight": 10}, {"name": "parameter-1002", "metadata": "PARAMETER_1002", "resourceName": "resource-1002", "resourceValue": 200, "weight": 20}, {"name": "parameter-1003", "metadata": "PARAMETER_1003", "resourceName": "resource-1003", "resourceValue": 300, "weight": 30}]}, {"name": "rarity-0003", "metadata": "RARITY_0003", "maximumParameterCount": 3, "parameterCounts": [{"count": 2, "weight": 5}, {"count": 3, "weight": 10}, {"count": 4, "weight": 15}], "parameters": [{"name": "parameter-2001", "metadata": "PARAMETER_2001", "resourceName": "resource-2001", "resourceValue": 1000, "weight": 2}, {"name": "parameter-2002", "metadata": "PARAMETER_2002", "resourceName": "resource-2002", "resourceValue": 2000, "weight": 4}, {"name": "parameter-2003", "metadata": "PARAMETER_2003", "resourceName": "resource-2003", "resourceValue": 3000, "weight": 6}, {"name": "parameter-0004", "metadata": "PARAMETER_0004", "resourceName": "resource-2004", "resourceValue": 4000, "weight": 8}]}]}')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.update_current_parameter_master({
    namespaceName="namespace1",
    settings="{\"version\": \"2023-07-18\", \"balanceParameterModels\": [{\"name\": \"balance-0001\", \"metadata\": \"BALANCE_0001\", \"totalValue\": 100, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}]}, {\"name\": \"balance-0002\", \"metadata\": \"BALANCE_0002\", \"totalValue\": 200, \"initialValueStrategy\": \"lottery\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\"}]}, {\"name\": \"balance-0003\", \"metadata\": \"BALANCE_0003\", \"totalValue\": 500, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}]}], \"rarityParameterModels\": [{\"name\": \"rarity-0001\", \"metadata\": \"RARITY_0001\", \"maximumParameterCount\": 5, \"parameterCounts\": [{\"count\": 0, \"weight\": 1}, {\"count\": 1, \"weight\": 2}, {\"count\": 2, \"weight\": 3}], \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\", \"resourceName\": \"resource-0001\", \"resourceValue\": 10, \"weight\": 1}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\", \"resourceName\": \"resource-0002\", \"resourceValue\": 20, \"weight\": 2}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\", \"resourceName\": \"resource-0003\", \"resourceValue\": 30, \"weight\": 3}]}, {\"name\": \"rarity-0002\", \"metadata\": \"RARITY_0002\", \"maximumParameterCount\": 10, \"parameterCounts\": [{\"count\": 1, \"weight\": 10}, {\"count\": 2, \"weight\": 20}, {\"count\": 3, \"weight\": 30}], \"parameters\": [{\"name\": \"parameter-1001\", \"metadata\": \"PARAMETER_1001\", \"resourceName\": \"resource-1001\", \"resourceValue\": 100, \"weight\": 10}, {\"name\": \"parameter-1002\", \"metadata\": \"PARAMETER_1002\", \"resourceName\": \"resource-1002\", \"resourceValue\": 200, \"weight\": 20}, {\"name\": \"parameter-1003\", \"metadata\": \"PARAMETER_1003\", \"resourceName\": \"resource-1003\", \"resourceValue\": 300, \"weight\": 30}]}, {\"name\": \"rarity-0003\", \"metadata\": \"RARITY_0003\", \"maximumParameterCount\": 3, \"parameterCounts\": [{\"count\": 2, \"weight\": 5}, {\"count\": 3, \"weight\": 10}, {\"count\": 4, \"weight\": 15}], \"parameters\": [{\"name\": \"parameter-2001\", \"metadata\": \"PARAMETER_2001\", \"resourceName\": \"resource-2001\", \"resourceValue\": 1000, \"weight\": 2}, {\"name\": \"parameter-2002\", \"metadata\": \"PARAMETER_2002\", \"resourceName\": \"resource-2002\", \"resourceValue\": 2000, \"weight\": 4}, {\"name\": \"parameter-2003\", \"metadata\": \"PARAMETER_2003\", \"resourceName\": \"resource-2003\", \"resourceValue\": 3000, \"weight\": 6}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\", \"resourceName\": \"resource-2004\", \"resourceValue\": 4000, \"weight\": 8}]}]}",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.update_current_parameter_master_async({
    namespaceName="namespace1",
    settings="{\"version\": \"2023-07-18\", \"balanceParameterModels\": [{\"name\": \"balance-0001\", \"metadata\": \"BALANCE_0001\", \"totalValue\": 100, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}]}, {\"name\": \"balance-0002\", \"metadata\": \"BALANCE_0002\", \"totalValue\": 200, \"initialValueStrategy\": \"lottery\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\"}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\"}]}, {\"name\": \"balance-0003\", \"metadata\": \"BALANCE_0003\", \"totalValue\": 500, \"initialValueStrategy\": \"average\", \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\"}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\"}]}], \"rarityParameterModels\": [{\"name\": \"rarity-0001\", \"metadata\": \"RARITY_0001\", \"maximumParameterCount\": 5, \"parameterCounts\": [{\"count\": 0, \"weight\": 1}, {\"count\": 1, \"weight\": 2}, {\"count\": 2, \"weight\": 3}], \"parameters\": [{\"name\": \"parameter-0001\", \"metadata\": \"PARAMETER_0001\", \"resourceName\": \"resource-0001\", \"resourceValue\": 10, \"weight\": 1}, {\"name\": \"parameter-0002\", \"metadata\": \"PARAMETER_0002\", \"resourceName\": \"resource-0002\", \"resourceValue\": 20, \"weight\": 2}, {\"name\": \"parameter-0003\", \"metadata\": \"PARAMETER_0003\", \"resourceName\": \"resource-0003\", \"resourceValue\": 30, \"weight\": 3}]}, {\"name\": \"rarity-0002\", \"metadata\": \"RARITY_0002\", \"maximumParameterCount\": 10, \"parameterCounts\": [{\"count\": 1, \"weight\": 10}, {\"count\": 2, \"weight\": 20}, {\"count\": 3, \"weight\": 30}], \"parameters\": [{\"name\": \"parameter-1001\", \"metadata\": \"PARAMETER_1001\", \"resourceName\": \"resource-1001\", \"resourceValue\": 100, \"weight\": 10}, {\"name\": \"parameter-1002\", \"metadata\": \"PARAMETER_1002\", \"resourceName\": \"resource-1002\", \"resourceValue\": 200, \"weight\": 20}, {\"name\": \"parameter-1003\", \"metadata\": \"PARAMETER_1003\", \"resourceName\": \"resource-1003\", \"resourceValue\": 300, \"weight\": 30}]}, {\"name\": \"rarity-0003\", \"metadata\": \"RARITY_0003\", \"maximumParameterCount\": 3, \"parameterCounts\": [{\"count\": 2, \"weight\": 5}, {\"count\": 3, \"weight\": 10}, {\"count\": 4, \"weight\": 15}], \"parameters\": [{\"name\": \"parameter-2001\", \"metadata\": \"PARAMETER_2001\", \"resourceName\": \"resource-2001\", \"resourceValue\": 1000, \"weight\": 2}, {\"name\": \"parameter-2002\", \"metadata\": \"PARAMETER_2002\", \"resourceName\": \"resource-2002\", \"resourceValue\": 2000, \"weight\": 4}, {\"name\": \"parameter-2003\", \"metadata\": \"PARAMETER_2003\", \"resourceName\": \"resource-2003\", \"resourceValue\": 3000, \"weight\": 6}, {\"name\": \"parameter-0004\", \"metadata\": \"PARAMETER_0004\", \"resourceName\": \"resource-2004\", \"resourceValue\": 4000, \"weight\": 8}]}]}",
})

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

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

result = api_result.result
item = result.item;

updateCurrentParameterMasterFromGitHub

Updates the currently available parameter settings

Request

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

Result

	Type	Description
item	CurrentParameterMaster	Updated and currently available parameter settings

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentParameterMasterFromGitHub(
    &enchant.UpdateCurrentParameterMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace1"),
        CheckoutSetting: &enchant.GitHubCheckoutSetting{
            ApiKeyId: pointy.String("$gitHubApiKey1.apiKeyId"),
            RepositoryName: pointy.String("gs2io/master-data"),
            SourcePath: pointy.String("path/to/file.json"),
            ReferenceType: pointy.String("branch"),
            BranchName: pointy.String("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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\UpdateCurrentParameterMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.UpdateCurrentParameterMasterFromGitHubRequest;
import io.gs2.enchant.result.UpdateCurrentParameterMasterFromGitHubResult;

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

try {
    UpdateCurrentParameterMasterFromGitHubResult result = client.updateCurrentParameterMasterFromGitHub(
        new UpdateCurrentParameterMasterFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("$gitHubApiKey1.apiKeyId")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    CurrentParameterMaster 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.UpdateCurrentParameterMasterFromGitHubRequest;
using Gs2.Gs2Enchant.Result.UpdateCurrentParameterMasterFromGitHubResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.UpdateCurrentParameterMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentParameterMasterFromGitHub(
    new Gs2.Gs2Enchant.Request.UpdateCurrentParameterMasterFromGitHubRequest()
        .WithNamespaceName("namespace1")
        .WithCheckoutSetting(new Gs2.Gs2Enchant.Model.GitHubCheckoutSetting()
            .WithApiKeyId("$gitHubApiKey1.apiKeyId")
            .WithRepositoryName("gs2io/master-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        ),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.updateCurrentParameterMasterFromGitHub(
        new Gs2Enchant.UpdateCurrentParameterMasterFromGitHubRequest()
            .withNamespaceName("namespace1")
            .withCheckoutSetting(new Gs2Enchant.model.GitHubCheckoutSetting()
                .withApiKeyId("$gitHubApiKey1.apiKeyId")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.update_current_parameter_master_from_git_hub(
        enchant.UpdateCurrentParameterMasterFromGitHubRequest()
            .with_namespace_name(self.hash1)
            .with_checkout_setting(enchant.GitHubCheckoutSetting()
                .with_api_key_id(self.git_hub_api_key1.api_key_id)
                .with_repository_name('gs2io/master-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

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

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

result = api_result.result
item = result.item;

client = gs2('enchant')

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

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

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

result = api_result.result
item = result.item;

describeBalanceParameterStatuses

Get list of balance parameter status

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
parameterName	string			~ 128 chars	Balance parameter model 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<BalanceParameterStatus>	List of Balance Parameter Model
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeBalanceParameterStatuses(
    &enchant.DescribeBalanceParameterStatusesRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("accessToken-0001"),
        ParameterName: pointy.String("balance-0001"),
        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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeBalanceParameterStatusesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBalanceParameterStatuses(
        (new DescribeBalanceParameterStatusesRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withParameterName("balance-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeBalanceParameterStatusesRequest;
import io.gs2.enchant.result.DescribeBalanceParameterStatusesResult;

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

try {
    DescribeBalanceParameterStatusesResult result = client.describeBalanceParameterStatuses(
        new DescribeBalanceParameterStatusesRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("balance-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<BalanceParameterStatus> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeBalanceParameterStatusesRequest;
using Gs2.Gs2Enchant.Result.DescribeBalanceParameterStatusesResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeBalanceParameterStatusesResult> asyncResult = null;
yield return client.DescribeBalanceParameterStatuses(
    new Gs2.Gs2Enchant.Request.DescribeBalanceParameterStatusesRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("accessToken-0001")
        .WithParameterName("balance-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeBalanceParameterStatuses(
        new Gs2Enchant.DescribeBalanceParameterStatusesRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("balance-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.describe_balance_parameter_statuses(
        enchant.DescribeBalanceParameterStatusesRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_parameter_name('balance-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.describe_balance_parameter_statuses({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="balance-0001",
    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;

client = gs2('enchant')

api_result_handler = client.describe_balance_parameter_statuses_async({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="balance-0001",
    pageToken=nil,
    limit=nil,
})

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

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

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

describeBalanceParameterStatusesByUserId

Get list of balance parameter status by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
parameterName	string			~ 128 chars	Balance parameter model name
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<BalanceParameterStatus>	List of Balance Parameter Model
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeBalanceParameterStatusesByUserId(
    &enchant.DescribeBalanceParameterStatusesByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("balance-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeBalanceParameterStatusesByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBalanceParameterStatusesByUserId(
        (new DescribeBalanceParameterStatusesByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("balance-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeBalanceParameterStatusesByUserIdRequest;
import io.gs2.enchant.result.DescribeBalanceParameterStatusesByUserIdResult;

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

try {
    DescribeBalanceParameterStatusesByUserIdResult result = client.describeBalanceParameterStatusesByUserId(
        new DescribeBalanceParameterStatusesByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<BalanceParameterStatus> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeBalanceParameterStatusesByUserIdRequest;
using Gs2.Gs2Enchant.Result.DescribeBalanceParameterStatusesByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeBalanceParameterStatusesByUserIdResult> asyncResult = null;
yield return client.DescribeBalanceParameterStatusesByUserId(
    new Gs2.Gs2Enchant.Request.DescribeBalanceParameterStatusesByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("balance-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeBalanceParameterStatusesByUserId(
        new Gs2Enchant.DescribeBalanceParameterStatusesByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.describe_balance_parameter_statuses_by_user_id(
        enchant.DescribeBalanceParameterStatusesByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('balance-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.describe_balance_parameter_statuses_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=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;

client = gs2('enchant')

api_result_handler = client.describe_balance_parameter_statuses_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

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

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

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

getBalanceParameterStatus

Retrieve balance parameter status

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Balance parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter

Result

	Type	Description
item	BalanceParameterStatus	Balance parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetBalanceParameterStatus(
    &enchant.GetBalanceParameterStatusRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("accessToken-0001"),
        ParameterName: pointy.String("balance-0001"),
        PropertyId: pointy.String("property-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetBalanceParameterStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBalanceParameterStatus(
        (new GetBalanceParameterStatusRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withParameterName("balance-0001")
            ->withPropertyId("property-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetBalanceParameterStatusRequest;
import io.gs2.enchant.result.GetBalanceParameterStatusResult;

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

try {
    GetBalanceParameterStatusResult result = client.getBalanceParameterStatus(
        new GetBalanceParameterStatusRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
    );
    BalanceParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetBalanceParameterStatusRequest;
using Gs2.Gs2Enchant.Result.GetBalanceParameterStatusResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetBalanceParameterStatusResult> asyncResult = null;
yield return client.GetBalanceParameterStatus(
    new Gs2.Gs2Enchant.Request.GetBalanceParameterStatusRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("accessToken-0001")
        .WithParameterName("balance-0001")
        .WithPropertyId("property-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getBalanceParameterStatus(
        new Gs2Enchant.GetBalanceParameterStatusRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_balance_parameter_status(
        enchant.GetBalanceParameterStatusRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_parameter_name('balance-0001')
            .with_property_id('property-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_balance_parameter_status({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_balance_parameter_status_async({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
})

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

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

result = api_result.result
item = result.item;

getBalanceParameterStatusByUserId

Get balance parameter status by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Balance parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BalanceParameterStatus	Balance parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetBalanceParameterStatusByUserId(
    &enchant.GetBalanceParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("balance-0001"),
        PropertyId: pointy.String("property-0001"),
        TimeOffsetToken: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetBalanceParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBalanceParameterStatusByUserId(
        (new GetBalanceParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("balance-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetBalanceParameterStatusByUserIdRequest;
import io.gs2.enchant.result.GetBalanceParameterStatusByUserIdResult;

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

try {
    GetBalanceParameterStatusByUserIdResult result = client.getBalanceParameterStatusByUserId(
        new GetBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    BalanceParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetBalanceParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.GetBalanceParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetBalanceParameterStatusByUserIdResult> asyncResult = null;
yield return client.GetBalanceParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.GetBalanceParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("balance-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getBalanceParameterStatusByUserId(
        new Gs2Enchant.GetBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_balance_parameter_status_by_user_id(
        enchant.GetBalanceParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('balance-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_balance_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_balance_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

deleteBalanceParameterStatusByUserId

Delete balance parameter status

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Balance parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BalanceParameterStatus	Deleted balance parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DeleteBalanceParameterStatusByUserId(
    &enchant.DeleteBalanceParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("balance-0001"),
        PropertyId: pointy.String("property-0001"),
        TimeOffsetToken: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DeleteBalanceParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteBalanceParameterStatusByUserId(
        (new DeleteBalanceParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("balance-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DeleteBalanceParameterStatusByUserIdRequest;
import io.gs2.enchant.result.DeleteBalanceParameterStatusByUserIdResult;

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

try {
    DeleteBalanceParameterStatusByUserIdResult result = client.deleteBalanceParameterStatusByUserId(
        new DeleteBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    BalanceParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DeleteBalanceParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.DeleteBalanceParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DeleteBalanceParameterStatusByUserIdResult> asyncResult = null;
yield return client.DeleteBalanceParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.DeleteBalanceParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("balance-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.deleteBalanceParameterStatusByUserId(
        new Gs2Enchant.DeleteBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.delete_balance_parameter_status_by_user_id(
        enchant.DeleteBalanceParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('balance-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.delete_balance_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.delete_balance_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

reDrawBalanceParameterStatusByUserId

Re-draw balance parameter by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
parameterName	string	✓		~ 128 chars	Balance parameter model name
propertyId	string	✓		~ 1024 chars	Property ID of the resource that owns the parameter
fixedParameterNames	List<string>		[]	~ 10 items	List of Parameter index not to re-draw
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	BalanceParameterStatus	Updated balance parameter status
old	BalanceParameterStatus	Balance parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.ReDrawBalanceParameterStatusByUserId(
    &enchant.ReDrawBalanceParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("balance-0001"),
        PropertyId: pointy.String("property-0001"),
        FixedParameterNames: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\ReDrawBalanceParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->reDrawBalanceParameterStatusByUserId(
        (new ReDrawBalanceParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("balance-0001")
            ->withPropertyId("property-0001")
            ->withFixedParameterNames(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.ReDrawBalanceParameterStatusByUserIdRequest;
import io.gs2.enchant.result.ReDrawBalanceParameterStatusByUserIdResult;

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

try {
    ReDrawBalanceParameterStatusByUserIdResult result = client.reDrawBalanceParameterStatusByUserId(
        new ReDrawBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withFixedParameterNames(null)
            .withTimeOffsetToken(null)
    );
    BalanceParameterStatus item = result.getItem();
    BalanceParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.ReDrawBalanceParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.ReDrawBalanceParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.ReDrawBalanceParameterStatusByUserIdResult> asyncResult = null;
yield return client.ReDrawBalanceParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.ReDrawBalanceParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("balance-0001")
        .WithPropertyId("property-0001")
        .WithFixedParameterNames(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.reDrawBalanceParameterStatusByUserId(
        new Gs2Enchant.ReDrawBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withFixedParameterNames(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.re_draw_balance_parameter_status_by_user_id(
        enchant.ReDrawBalanceParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('balance-0001')
            .with_property_id('property-0001')
            .with_fixed_parameter_names(None)
            .with_time_offset_token(None)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.re_draw_balance_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    fixedParameterNames=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.re_draw_balance_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    fixedParameterNames=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
old = result.old;

reDrawBalanceParameterStatusByStampSheet

Execute re-draw of balance parameter status as acquire action

Request

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

Result

	Type	Description
item	BalanceParameterStatus	Updated balance parameter status
old	BalanceParameterStatus	Balance parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.ReDrawBalanceParameterStatusByStampSheet(
    &enchant.ReDrawBalanceParameterStatusByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\ReDrawBalanceParameterStatusByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->reDrawBalanceParameterStatusByStampSheet(
        (new ReDrawBalanceParameterStatusByStampSheetRequest())
            ->withStampSheet(self::stampSheet)
            ->withKeyId(self::key-0001)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.ReDrawBalanceParameterStatusByStampSheetRequest;
import io.gs2.enchant.result.ReDrawBalanceParameterStatusByStampSheetResult;

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

try {
    ReDrawBalanceParameterStatusByStampSheetResult result = client.reDrawBalanceParameterStatusByStampSheet(
        new ReDrawBalanceParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    BalanceParameterStatus item = result.getItem();
    BalanceParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.ReDrawBalanceParameterStatusByStampSheetRequest;
using Gs2.Gs2Enchant.Result.ReDrawBalanceParameterStatusByStampSheetResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.ReDrawBalanceParameterStatusByStampSheetResult> asyncResult = null;
yield return client.ReDrawBalanceParameterStatusByStampSheet(
    new Gs2.Gs2Enchant.Request.ReDrawBalanceParameterStatusByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.reDrawBalanceParameterStatusByStampSheet(
        new Gs2Enchant.ReDrawBalanceParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.re_draw_balance_parameter_status_by_stamp_sheet(
        enchant.ReDrawBalanceParameterStatusByStampSheetRequest()
            .with_stamp_sheet(self.stamp_sheet)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.re_draw_balance_parameter_status_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.re_draw_balance_parameter_status_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

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

result = api_result.result
item = result.item;
old = result.old;

setBalanceParameterStatusByUserId

Set any value to balance parameter status by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Balance parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter
parameterValues	List<BalanceParameterValue>	✓	1 ~ 10 items	List of balance parameter values
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BalanceParameterStatus	Updated balance parameter status
old	BalanceParameterStatus	Balance parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.SetBalanceParameterStatusByUserId(
    &enchant.SetBalanceParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("balance-0001"),
        PropertyId: pointy.String("property-0001"),
        ParameterValues: []enchant.BalanceParameterValue{
            enchant.BalanceParameterValue{
                Name: pointy.String("parameter-0001"),
                Value: pointy.Int64(100),
            },
            enchant.BalanceParameterValue{
                Name: pointy.String("parameter-0002"),
                Value: pointy.Int64(200),
            },
        },
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\SetBalanceParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setBalanceParameterStatusByUserId(
        (new SetBalanceParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("balance-0001")
            ->withPropertyId("property-0001")
            ->withParameterValues([
                (new BalanceParameterValue())
                    ->withName("parameter-0001")
                    ->withValue(100),
                (new BalanceParameterValue())
                    ->withName("parameter-0002")
                    ->withValue(200),
            ])
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.SetBalanceParameterStatusByUserIdRequest;
import io.gs2.enchant.result.SetBalanceParameterStatusByUserIdResult;

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

try {
    SetBalanceParameterStatusByUserIdResult result = client.setBalanceParameterStatusByUserId(
        new SetBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withParameterValues(Arrays.asList(
                new BalanceParameterValue()
                    .withName("parameter-0001")
                    .withValue(100L),
                new BalanceParameterValue()
                    .withName("parameter-0002")
                    .withValue(200L)
            ))
            .withTimeOffsetToken(null)
    );
    BalanceParameterStatus item = result.getItem();
    BalanceParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.SetBalanceParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.SetBalanceParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.SetBalanceParameterStatusByUserIdResult> asyncResult = null;
yield return client.SetBalanceParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.SetBalanceParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("balance-0001")
        .WithPropertyId("property-0001")
        .WithParameterValues(new Gs2.Gs2Enchant.Model.BalanceParameterValue[] {
            new Gs2.Gs2Enchant.Model.BalanceParameterValue()
                .WithName("parameter-0001")
                .WithValue(100L),
            new Gs2.Gs2Enchant.Model.BalanceParameterValue()
                .WithName("parameter-0002")
                .WithValue(200L),
        })
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.setBalanceParameterStatusByUserId(
        new Gs2Enchant.SetBalanceParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withParameterValues([
                new Gs2Enchant.model.BalanceParameterValue()
                    .withName("parameter-0001")
                    .withValue(100),
                new Gs2Enchant.model.BalanceParameterValue()
                    .withName("parameter-0002")
                    .withValue(200),
            ])
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.set_balance_parameter_status_by_user_id(
        enchant.SetBalanceParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('balance-0001')
            .with_property_id('property-0001')
            .with_parameter_values([
                enchant.BalanceParameterValue()
                    .with_name('parameter-0001')
                    .with_value(100),
                enchant.BalanceParameterValue()
                    .with_name('parameter-0002')
                    .with_value(200),
            ])
            .with_time_offset_token(None)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.set_balance_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    parameterValues={
        {
            name="parameter-0001",
            value=100,
        },
        {
            name="parameter-0002",
            value=200,
        }
    },
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.set_balance_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    parameterValues={
        {
            name="parameter-0001",
            value=100,
        },
        {
            name="parameter-0002",
            value=200,
        }
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
old = result.old;

setBalanceParameterStatusByStampSheet

Execute setting any value to balance parameter status as acquire action

Request

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

Result

	Type	Description
item	BalanceParameterStatus	Updated balance parameter status
old	BalanceParameterStatus	Balance parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.SetBalanceParameterStatusByStampSheet(
    &enchant.SetBalanceParameterStatusByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\SetBalanceParameterStatusByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setBalanceParameterStatusByStampSheet(
        (new SetBalanceParameterStatusByStampSheetRequest())
            ->withStampSheet(self::stampSheet)
            ->withKeyId(self::key-0001)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.SetBalanceParameterStatusByStampSheetRequest;
import io.gs2.enchant.result.SetBalanceParameterStatusByStampSheetResult;

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

try {
    SetBalanceParameterStatusByStampSheetResult result = client.setBalanceParameterStatusByStampSheet(
        new SetBalanceParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    BalanceParameterStatus item = result.getItem();
    BalanceParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.SetBalanceParameterStatusByStampSheetRequest;
using Gs2.Gs2Enchant.Result.SetBalanceParameterStatusByStampSheetResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.SetBalanceParameterStatusByStampSheetResult> asyncResult = null;
yield return client.SetBalanceParameterStatusByStampSheet(
    new Gs2.Gs2Enchant.Request.SetBalanceParameterStatusByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.setBalanceParameterStatusByStampSheet(
        new Gs2Enchant.SetBalanceParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.set_balance_parameter_status_by_stamp_sheet(
        enchant.SetBalanceParameterStatusByStampSheetRequest()
            .with_stamp_sheet(self.stamp_sheet)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.set_balance_parameter_status_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.set_balance_parameter_status_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

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

result = api_result.result
item = result.item;
old = result.old;

describeRarityParameterStatuses

Get list of rarity parameter status

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
parameterName	string			~ 128 chars	Rarity parameter model 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<RarityParameterStatus>	List of Rarity Parameter Model
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeRarityParameterStatuses(
    &enchant.DescribeRarityParameterStatusesRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("accessToken-0001"),
        ParameterName: pointy.String("rarity-0001"),
        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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeRarityParameterStatusesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeRarityParameterStatuses(
        (new DescribeRarityParameterStatusesRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withParameterName("rarity-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeRarityParameterStatusesRequest;
import io.gs2.enchant.result.DescribeRarityParameterStatusesResult;

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

try {
    DescribeRarityParameterStatusesResult result = client.describeRarityParameterStatuses(
        new DescribeRarityParameterStatusesRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("rarity-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<RarityParameterStatus> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeRarityParameterStatusesRequest;
using Gs2.Gs2Enchant.Result.DescribeRarityParameterStatusesResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeRarityParameterStatusesResult> asyncResult = null;
yield return client.DescribeRarityParameterStatuses(
    new Gs2.Gs2Enchant.Request.DescribeRarityParameterStatusesRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("accessToken-0001")
        .WithParameterName("rarity-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeRarityParameterStatuses(
        new Gs2Enchant.DescribeRarityParameterStatusesRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("rarity-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.describe_rarity_parameter_statuses(
        enchant.DescribeRarityParameterStatusesRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_parameter_name('rarity-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.describe_rarity_parameter_statuses({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="rarity-0001",
    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;

client = gs2('enchant')

api_result_handler = client.describe_rarity_parameter_statuses_async({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="rarity-0001",
    pageToken=nil,
    limit=nil,
})

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

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

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

describeRarityParameterStatusesByUserId

Get list of rarity parameter status by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
parameterName	string			~ 128 chars	Rarity parameter model name
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<RarityParameterStatus>	List of Rarity Parameter Model
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/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DescribeRarityParameterStatusesByUserId(
    &enchant.DescribeRarityParameterStatusesByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("balance-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DescribeRarityParameterStatusesByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeRarityParameterStatusesByUserId(
        (new DescribeRarityParameterStatusesByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("balance-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DescribeRarityParameterStatusesByUserIdRequest;
import io.gs2.enchant.result.DescribeRarityParameterStatusesByUserIdResult;

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

try {
    DescribeRarityParameterStatusesByUserIdResult result = client.describeRarityParameterStatusesByUserId(
        new DescribeRarityParameterStatusesByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<RarityParameterStatus> 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DescribeRarityParameterStatusesByUserIdRequest;
using Gs2.Gs2Enchant.Result.DescribeRarityParameterStatusesByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DescribeRarityParameterStatusesByUserIdResult> asyncResult = null;
yield return client.DescribeRarityParameterStatusesByUserId(
    new Gs2.Gs2Enchant.Request.DescribeRarityParameterStatusesByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("balance-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.describeRarityParameterStatusesByUserId(
        new Gs2Enchant.DescribeRarityParameterStatusesByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.describe_rarity_parameter_statuses_by_user_id(
        enchant.DescribeRarityParameterStatusesByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('balance-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.describe_rarity_parameter_statuses_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=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;

client = gs2('enchant')

api_result_handler = client.describe_rarity_parameter_statuses_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

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

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

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

getRarityParameterStatus

Retrieve rarity parameter status

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Rarity parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter

Result

	Type	Description
item	RarityParameterStatus	Rarity parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetRarityParameterStatus(
    &enchant.GetRarityParameterStatusRequest {
        NamespaceName: pointy.String("namespace1"),
        AccessToken: pointy.String("accessToken-0001"),
        ParameterName: pointy.String("balance-0001"),
        PropertyId: pointy.String("property-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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetRarityParameterStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getRarityParameterStatus(
        (new GetRarityParameterStatusRequest())
            ->withNamespaceName(self::namespace1)
            ->withAccessToken(self::$accessToken0001)
            ->withParameterName("balance-0001")
            ->withPropertyId("property-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetRarityParameterStatusRequest;
import io.gs2.enchant.result.GetRarityParameterStatusResult;

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

try {
    GetRarityParameterStatusResult result = client.getRarityParameterStatus(
        new GetRarityParameterStatusRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
    );
    RarityParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetRarityParameterStatusRequest;
using Gs2.Gs2Enchant.Result.GetRarityParameterStatusResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetRarityParameterStatusResult> asyncResult = null;
yield return client.GetRarityParameterStatus(
    new Gs2.Gs2Enchant.Request.GetRarityParameterStatusRequest()
        .WithNamespaceName("namespace1")
        .WithAccessToken("accessToken-0001")
        .WithParameterName("balance-0001")
        .WithPropertyId("property-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getRarityParameterStatus(
        new Gs2Enchant.GetRarityParameterStatusRequest()
            .withNamespaceName("namespace1")
            .withAccessToken("accessToken-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_rarity_parameter_status(
        enchant.GetRarityParameterStatusRequest()
            .with_namespace_name(self.hash1)
            .with_access_token(self.access_token_0001)
            .with_parameter_name('balance-0001')
            .with_property_id('property-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_rarity_parameter_status({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_rarity_parameter_status_async({
    namespaceName="namespace1",
    accessToken="accessToken-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
})

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

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

result = api_result.result
item = result.item;

getRarityParameterStatusByUserId

Get rarity parameter status by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Rarity parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	RarityParameterStatus	Rarity parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.GetRarityParameterStatusByUserId(
    &enchant.GetRarityParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("rarity-0001"),
        PropertyId: pointy.String("property-0001"),
        TimeOffsetToken: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\GetRarityParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getRarityParameterStatusByUserId(
        (new GetRarityParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("rarity-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.GetRarityParameterStatusByUserIdRequest;
import io.gs2.enchant.result.GetRarityParameterStatusByUserIdResult;

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

try {
    GetRarityParameterStatusByUserIdResult result = client.getRarityParameterStatusByUserId(
        new GetRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    RarityParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.GetRarityParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.GetRarityParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.GetRarityParameterStatusByUserIdResult> asyncResult = null;
yield return client.GetRarityParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.GetRarityParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("rarity-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.getRarityParameterStatusByUserId(
        new Gs2Enchant.GetRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.get_rarity_parameter_status_by_user_id(
        enchant.GetRarityParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('rarity-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.get_rarity_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.get_rarity_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

deleteRarityParameterStatusByUserId

Delete rarity parameter status

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Rarity parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	RarityParameterStatus	Deleted rarity parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.DeleteRarityParameterStatusByUserId(
    &enchant.DeleteRarityParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("rarity-0001"),
        PropertyId: pointy.String("property-0001"),
        TimeOffsetToken: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\DeleteRarityParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteRarityParameterStatusByUserId(
        (new DeleteRarityParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("rarity-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.DeleteRarityParameterStatusByUserIdRequest;
import io.gs2.enchant.result.DeleteRarityParameterStatusByUserIdResult;

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

try {
    DeleteRarityParameterStatusByUserIdResult result = client.deleteRarityParameterStatusByUserId(
        new DeleteRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    RarityParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.DeleteRarityParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.DeleteRarityParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.DeleteRarityParameterStatusByUserIdResult> asyncResult = null;
yield return client.DeleteRarityParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.DeleteRarityParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("rarity-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.deleteRarityParameterStatusByUserId(
        new Gs2Enchant.DeleteRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.delete_rarity_parameter_status_by_user_id(
        enchant.DeleteRarityParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('rarity-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.delete_rarity_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.delete_rarity_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

reDrawRarityParameterStatusByUserId

Re-draw rarity parameter status by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Rarity parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter
fixedParameterNames	List<string>		~ 10 items	List of Parameter index not to re-draw
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	RarityParameterStatus	Updated rarity parameter status
old	RarityParameterStatus	Rarity parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.ReDrawRarityParameterStatusByUserId(
    &enchant.ReDrawRarityParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("rarity-0001"),
        PropertyId: pointy.String("property-0001"),
        FixedParameterNames: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\ReDrawRarityParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->reDrawRarityParameterStatusByUserId(
        (new ReDrawRarityParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("rarity-0001")
            ->withPropertyId("property-0001")
            ->withFixedParameterNames(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.ReDrawRarityParameterStatusByUserIdRequest;
import io.gs2.enchant.result.ReDrawRarityParameterStatusByUserIdResult;

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

try {
    ReDrawRarityParameterStatusByUserIdResult result = client.reDrawRarityParameterStatusByUserId(
        new ReDrawRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withFixedParameterNames(null)
            .withTimeOffsetToken(null)
    );
    RarityParameterStatus item = result.getItem();
    RarityParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.ReDrawRarityParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.ReDrawRarityParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.ReDrawRarityParameterStatusByUserIdResult> asyncResult = null;
yield return client.ReDrawRarityParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.ReDrawRarityParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("rarity-0001")
        .WithPropertyId("property-0001")
        .WithFixedParameterNames(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.reDrawRarityParameterStatusByUserId(
        new Gs2Enchant.ReDrawRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withFixedParameterNames(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.re_draw_rarity_parameter_status_by_user_id(
        enchant.ReDrawRarityParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('rarity-0001')
            .with_property_id('property-0001')
            .with_fixed_parameter_names(None)
            .with_time_offset_token(None)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.re_draw_rarity_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    fixedParameterNames=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.re_draw_rarity_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    fixedParameterNames=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
old = result.old;

reDrawRarityParameterStatusByStampSheet

Execute re-draw rarity parameter status as a acquire action

Request

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

Result

	Type	Description
item	RarityParameterStatus	Updated rarity parameter status
old	RarityParameterStatus	Rarity parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.ReDrawRarityParameterStatusByStampSheet(
    &enchant.ReDrawRarityParameterStatusByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\ReDrawRarityParameterStatusByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->reDrawRarityParameterStatusByStampSheet(
        (new ReDrawRarityParameterStatusByStampSheetRequest())
            ->withStampSheet(self::stampSheet)
            ->withKeyId(self::key-0001)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.ReDrawRarityParameterStatusByStampSheetRequest;
import io.gs2.enchant.result.ReDrawRarityParameterStatusByStampSheetResult;

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

try {
    ReDrawRarityParameterStatusByStampSheetResult result = client.reDrawRarityParameterStatusByStampSheet(
        new ReDrawRarityParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    RarityParameterStatus item = result.getItem();
    RarityParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.ReDrawRarityParameterStatusByStampSheetRequest;
using Gs2.Gs2Enchant.Result.ReDrawRarityParameterStatusByStampSheetResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.ReDrawRarityParameterStatusByStampSheetResult> asyncResult = null;
yield return client.ReDrawRarityParameterStatusByStampSheet(
    new Gs2.Gs2Enchant.Request.ReDrawRarityParameterStatusByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.reDrawRarityParameterStatusByStampSheet(
        new Gs2Enchant.ReDrawRarityParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.re_draw_rarity_parameter_status_by_stamp_sheet(
        enchant.ReDrawRarityParameterStatusByStampSheetRequest()
            .with_stamp_sheet(self.stamp_sheet)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.re_draw_rarity_parameter_status_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.re_draw_rarity_parameter_status_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

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

result = api_result.result
item = result.item;
old = result.old;

addRarityParameterStatusByUserId

Add rarity parameter status by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
parameterName	string	✓		~ 128 chars	Rarity parameter model name
propertyId	string	✓		~ 1024 chars	Property ID of the resource that owns the parameter
count	int	✓	1	1 ~ 10	Number of parameters to add
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	RarityParameterStatus	Updated rarity parameter status
old	RarityParameterStatus	Rarity parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.AddRarityParameterStatusByUserId(
    &enchant.AddRarityParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("balance-0001"),
        PropertyId: pointy.String("property-0001"),
        Count: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\AddRarityParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->addRarityParameterStatusByUserId(
        (new AddRarityParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("balance-0001")
            ->withPropertyId("property-0001")
            ->withCount(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.AddRarityParameterStatusByUserIdRequest;
import io.gs2.enchant.result.AddRarityParameterStatusByUserIdResult;

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

try {
    AddRarityParameterStatusByUserIdResult result = client.addRarityParameterStatusByUserId(
        new AddRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withCount(null)
            .withTimeOffsetToken(null)
    );
    RarityParameterStatus item = result.getItem();
    RarityParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.AddRarityParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.AddRarityParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.AddRarityParameterStatusByUserIdResult> asyncResult = null;
yield return client.AddRarityParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.AddRarityParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("balance-0001")
        .WithPropertyId("property-0001")
        .WithCount(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.addRarityParameterStatusByUserId(
        new Gs2Enchant.AddRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("balance-0001")
            .withPropertyId("property-0001")
            .withCount(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.add_rarity_parameter_status_by_user_id(
        enchant.AddRarityParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('balance-0001')
            .with_property_id('property-0001')
            .with_count(None)
            .with_time_offset_token(None)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.add_rarity_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    count=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.add_rarity_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="balance-0001",
    propertyId="property-0001",
    count=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
old = result.old;

addRarityParameterStatusByStampSheet

Execute add rarity parameter as a acquire action

Request

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

Result

	Type	Description
item	RarityParameterStatus	Updated rarity parameter status
old	RarityParameterStatus	Rarity parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.AddRarityParameterStatusByStampSheet(
    &enchant.AddRarityParameterStatusByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\AddRarityParameterStatusByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->addRarityParameterStatusByStampSheet(
        (new AddRarityParameterStatusByStampSheetRequest())
            ->withStampSheet(self::stampSheet)
            ->withKeyId(self::key-0001)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.AddRarityParameterStatusByStampSheetRequest;
import io.gs2.enchant.result.AddRarityParameterStatusByStampSheetResult;

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

try {
    AddRarityParameterStatusByStampSheetResult result = client.addRarityParameterStatusByStampSheet(
        new AddRarityParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    RarityParameterStatus item = result.getItem();
    RarityParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.AddRarityParameterStatusByStampSheetRequest;
using Gs2.Gs2Enchant.Result.AddRarityParameterStatusByStampSheetResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.AddRarityParameterStatusByStampSheetResult> asyncResult = null;
yield return client.AddRarityParameterStatusByStampSheet(
    new Gs2.Gs2Enchant.Request.AddRarityParameterStatusByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.addRarityParameterStatusByStampSheet(
        new Gs2Enchant.AddRarityParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.add_rarity_parameter_status_by_stamp_sheet(
        enchant.AddRarityParameterStatusByStampSheetRequest()
            .with_stamp_sheet(self.stamp_sheet)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.add_rarity_parameter_status_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.add_rarity_parameter_status_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

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

result = api_result.result
item = result.item;
old = result.old;

verifyRarityParameterStatus

Verify rarity parameter

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Rarity parameter model name
accessToken	string		✓		~ 128 chars	User Id
propertyId	string		✓		~ 1024 chars	Property ID of the resource that owns the parameter
verifyType	enum { “havent”, “have”, “count” }		✓		~ 128 chars	Type of verification
parameterValueName	string	{verifyType} in [“havent”, “have”]	✓		~ 64 chars	Name
parameterCount	int	{verifyType} in [“count”]	✓		~ 10	Number of parameters to verify
multiplyValueSpecifyingQuantity	bool		✓	false		Whether to multiply the value used for verification when specifying the quantity

Enumeration type definition to specify as verifyType

Enumerator String Definition	Description
havent	The specified parameter must not be held
have	The specified parameter must be held
count	The number of parameters held must be the specified number

Result

	Type	Description
item	RarityParameterStatus	Rarity parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.VerifyRarityParameterStatus(
    &enchant.VerifyRarityParameterStatusRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("balance-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        PropertyId: pointy.String("property-0001"),
        VerifyType: pointy.String("have"),
        ParameterValueName: pointy.String("parameter-0001"),
        ParameterCount: nil,
        MultiplyValueSpecifyingQuantity: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\VerifyRarityParameterStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyRarityParameterStatus(
        (new VerifyRarityParameterStatusRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("balance-0001")
            ->withAccessToken(self::$accessToken0001)
            ->withPropertyId("property-0001")
            ->withVerifyType("have")
            ->withParameterValueName("parameter-0001")
            ->withParameterCount(null)
            ->withMultiplyValueSpecifyingQuantity(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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.VerifyRarityParameterStatusRequest;
import io.gs2.enchant.result.VerifyRarityParameterStatusResult;

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

try {
    VerifyRarityParameterStatusResult result = client.verifyRarityParameterStatus(
        new VerifyRarityParameterStatusRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withVerifyType("have")
            .withParameterValueName("parameter-0001")
            .withParameterCount(null)
            .withMultiplyValueSpecifyingQuantity(null)
    );
    RarityParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.VerifyRarityParameterStatusRequest;
using Gs2.Gs2Enchant.Result.VerifyRarityParameterStatusResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.VerifyRarityParameterStatusResult> asyncResult = null;
yield return client.VerifyRarityParameterStatus(
    new Gs2.Gs2Enchant.Request.VerifyRarityParameterStatusRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("balance-0001")
        .WithAccessToken("accessToken-0001")
        .WithPropertyId("property-0001")
        .WithVerifyType("have")
        .WithParameterValueName("parameter-0001")
        .WithParameterCount(null)
        .WithMultiplyValueSpecifyingQuantity(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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.verifyRarityParameterStatus(
        new Gs2Enchant.VerifyRarityParameterStatusRequest()
            .withNamespaceName("namespace1")
            .withParameterName("balance-0001")
            .withAccessToken("accessToken-0001")
            .withPropertyId("property-0001")
            .withVerifyType("have")
            .withParameterValueName("parameter-0001")
            .withParameterCount(null)
            .withMultiplyValueSpecifyingQuantity(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.verify_rarity_parameter_status(
        enchant.VerifyRarityParameterStatusRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('balance-0001')
            .with_access_token(self.access_token_0001)
            .with_property_id('property-0001')
            .with_verify_type('have')
            .with_parameter_value_name('parameter-0001')
            .with_parameter_count(None)
            .with_multiply_value_specifying_quantity(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.verify_rarity_parameter_status({
    namespaceName="namespace1",
    parameterName="balance-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    verifyType="have",
    parameterValueName="parameter-0001",
    parameterCount=nil,
    multiplyValueSpecifyingQuantity=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.verify_rarity_parameter_status_async({
    namespaceName="namespace1",
    parameterName="balance-0001",
    accessToken="accessToken-0001",
    propertyId="property-0001",
    verifyType="have",
    parameterValueName="parameter-0001",
    parameterCount=nil,
    multiplyValueSpecifyingQuantity=nil,
})

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

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

result = api_result.result
item = result.item;

verifyRarityParameterStatusByUserId

Verify rarity parameter by specifying user ID

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
parameterName	string		✓		~ 128 chars	Rarity parameter model name
userId	string		✓		~ 128 chars	User Id
propertyId	string		✓		~ 1024 chars	Property ID of the resource that owns the parameter
verifyType	enum { “havent”, “have”, “count” }		✓		~ 128 chars	Type of verification
parameterValueName	string	{verifyType} in [“havent”, “have”]	✓		~ 64 chars	Name
parameterCount	int	{verifyType} in [“count”]	✓		~ 10	Number of parameters to verify
multiplyValueSpecifyingQuantity	bool		✓	false		Whether to multiply the value used for verification when specifying the quantity
timeOffsetToken	string				~ 1024 chars	Time offset token

Enumeration type definition to specify as verifyType

Enumerator String Definition	Description
havent	The specified parameter must not be held
have	The specified parameter must be held
count	The number of parameters held must be the specified number

Result

	Type	Description
item	RarityParameterStatus	Rarity parameter status

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.VerifyRarityParameterStatusByUserId(
    &enchant.VerifyRarityParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        ParameterName: pointy.String("rarity-0001"),
        UserId: pointy.String("user-0001"),
        PropertyId: pointy.String("property-0001"),
        VerifyType: pointy.String("have"),
        ParameterValueName: pointy.String("parameter-0001"),
        ParameterCount: nil,
        MultiplyValueSpecifyingQuantity: nil,
        TimeOffsetToken: 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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\VerifyRarityParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyRarityParameterStatusByUserId(
        (new VerifyRarityParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withParameterName("rarity-0001")
            ->withUserId("user-0001")
            ->withPropertyId("property-0001")
            ->withVerifyType("have")
            ->withParameterValueName("parameter-0001")
            ->withParameterCount(null)
            ->withMultiplyValueSpecifyingQuantity(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.VerifyRarityParameterStatusByUserIdRequest;
import io.gs2.enchant.result.VerifyRarityParameterStatusByUserIdResult;

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

try {
    VerifyRarityParameterStatusByUserIdResult result = client.verifyRarityParameterStatusByUserId(
        new VerifyRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withVerifyType("have")
            .withParameterValueName("parameter-0001")
            .withParameterCount(null)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
    RarityParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.VerifyRarityParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.VerifyRarityParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.VerifyRarityParameterStatusByUserIdResult> asyncResult = null;
yield return client.VerifyRarityParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.VerifyRarityParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithParameterName("rarity-0001")
        .WithUserId("user-0001")
        .WithPropertyId("property-0001")
        .WithVerifyType("have")
        .WithParameterValueName("parameter-0001")
        .WithParameterCount(null)
        .WithMultiplyValueSpecifyingQuantity(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.verifyRarityParameterStatusByUserId(
        new Gs2Enchant.VerifyRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withParameterName("rarity-0001")
            .withUserId("user-0001")
            .withPropertyId("property-0001")
            .withVerifyType("have")
            .withParameterValueName("parameter-0001")
            .withParameterCount(null)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.verify_rarity_parameter_status_by_user_id(
        enchant.VerifyRarityParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_parameter_name('rarity-0001')
            .with_user_id('user-0001')
            .with_property_id('property-0001')
            .with_verify_type('have')
            .with_parameter_value_name('parameter-0001')
            .with_parameter_count(None)
            .with_multiply_value_specifying_quantity(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.verify_rarity_parameter_status_by_user_id({
    namespaceName="namespace1",
    parameterName="rarity-0001",
    userId="user-0001",
    propertyId="property-0001",
    verifyType="have",
    parameterValueName="parameter-0001",
    parameterCount=nil,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('enchant')

api_result_handler = client.verify_rarity_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    parameterName="rarity-0001",
    userId="user-0001",
    propertyId="property-0001",
    verifyType="have",
    parameterValueName="parameter-0001",
    parameterCount=nil,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

verifyRarityParameterStatusByStampTask

Execute verification of rarity parameter as a verify action

Request

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

Result

	Type	Description
item	RarityParameterStatus	Rarity parameter status
newContextStack	string	Request of context in which verify action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.VerifyRarityParameterStatusByStampTask(
    &enchant.VerifyRarityParameterStatusByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
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\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\VerifyRarityParameterStatusByStampTaskRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyRarityParameterStatusByStampTask(
        (new VerifyRarityParameterStatusByStampTaskRequest())
            ->withStampTask(self::stampTask)
            ->withKeyId(self::key-0001)
    );
    $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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.VerifyRarityParameterStatusByStampTaskRequest;
import io.gs2.enchant.result.VerifyRarityParameterStatusByStampTaskResult;

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

try {
    VerifyRarityParameterStatusByStampTaskResult result = client.verifyRarityParameterStatusByStampTask(
        new VerifyRarityParameterStatusByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    RarityParameterStatus 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.VerifyRarityParameterStatusByStampTaskRequest;
using Gs2.Gs2Enchant.Result.VerifyRarityParameterStatusByStampTaskResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.VerifyRarityParameterStatusByStampTaskResult> asyncResult = null;
yield return client.VerifyRarityParameterStatusByStampTask(
    new Gs2.Gs2Enchant.Request.VerifyRarityParameterStatusByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    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 Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.verifyRarityParameterStatusByStampTask(
        new Gs2Enchant.VerifyRarityParameterStatusByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.verify_rarity_parameter_status_by_stamp_task(
        enchant.VerifyRarityParameterStatusByStampTaskRequest()
            .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('enchant')

api_result = client.verify_rarity_parameter_status_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

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;

client = gs2('enchant')

api_result_handler = client.verify_rarity_parameter_status_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

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

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

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

setRarityParameterStatusByUserId

Set any value to rarity parameter by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
parameterName	string	✓	~ 128 chars	Rarity parameter model name
propertyId	string	✓	~ 1024 chars	Property ID of the resource that owns the parameter
parameterValues	List<RarityParameterValue>		~ 10 items	List of rarity parameter values
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	RarityParameterStatus	Updated rarity parameter status
old	RarityParameterStatus	Rarity parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.SetRarityParameterStatusByUserId(
    &enchant.SetRarityParameterStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace1"),
        UserId: pointy.String("user-0001"),
        ParameterName: pointy.String("rarity-0001"),
        PropertyId: pointy.String("property-0001"),
        ParameterValues: []enchant.RarityParameterValue{
            enchant.RarityParameterValue{
                Name: pointy.String("parameter-0001"),
                ResourceName: pointy.String("str"),
                ResourceValue: pointy.Int64(100),
            },
            enchant.RarityParameterValue{
                Name: pointy.String("parameter-0002"),
                ResourceName: pointy.String("def"),
                ResourceValue: pointy.Int64(200),
            },
        },
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\SetRarityParameterStatusByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setRarityParameterStatusByUserId(
        (new SetRarityParameterStatusByUserIdRequest())
            ->withNamespaceName(self::namespace1)
            ->withUserId("user-0001")
            ->withParameterName("rarity-0001")
            ->withPropertyId("property-0001")
            ->withParameterValues([
                (new RarityParameterValue())
                    ->withName("parameter-0001")
                    ->withResourceName("str")
                    ->withResourceValue(100),
                (new RarityParameterValue())
                    ->withName("parameter-0002")
                    ->withResourceName("def")
                    ->withResourceValue(200),
            ])
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.SetRarityParameterStatusByUserIdRequest;
import io.gs2.enchant.result.SetRarityParameterStatusByUserIdResult;

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

try {
    SetRarityParameterStatusByUserIdResult result = client.setRarityParameterStatusByUserId(
        new SetRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withParameterValues(Arrays.asList(
                new RarityParameterValue()
                    .withName("parameter-0001")
                    .withResourceName("str")
                    .withResourceValue(100L),
                new RarityParameterValue()
                    .withName("parameter-0002")
                    .withResourceName("def")
                    .withResourceValue(200L)
            ))
            .withTimeOffsetToken(null)
    );
    RarityParameterStatus item = result.getItem();
    RarityParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.SetRarityParameterStatusByUserIdRequest;
using Gs2.Gs2Enchant.Result.SetRarityParameterStatusByUserIdResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.SetRarityParameterStatusByUserIdResult> asyncResult = null;
yield return client.SetRarityParameterStatusByUserId(
    new Gs2.Gs2Enchant.Request.SetRarityParameterStatusByUserIdRequest()
        .WithNamespaceName("namespace1")
        .WithUserId("user-0001")
        .WithParameterName("rarity-0001")
        .WithPropertyId("property-0001")
        .WithParameterValues(new Gs2.Gs2Enchant.Model.RarityParameterValue[] {
            new Gs2.Gs2Enchant.Model.RarityParameterValue()
                .WithName("parameter-0001")
                .WithResourceName("str")
                .WithResourceValue(100L),
            new Gs2.Gs2Enchant.Model.RarityParameterValue()
                .WithName("parameter-0002")
                .WithResourceName("def")
                .WithResourceValue(200L),
        })
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.setRarityParameterStatusByUserId(
        new Gs2Enchant.SetRarityParameterStatusByUserIdRequest()
            .withNamespaceName("namespace1")
            .withUserId("user-0001")
            .withParameterName("rarity-0001")
            .withPropertyId("property-0001")
            .withParameterValues([
                new Gs2Enchant.model.RarityParameterValue()
                    .withName("parameter-0001")
                    .withResourceName("str")
                    .withResourceValue(100),
                new Gs2Enchant.model.RarityParameterValue()
                    .withName("parameter-0002")
                    .withResourceName("def")
                    .withResourceValue(200),
            ])
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.set_rarity_parameter_status_by_user_id(
        enchant.SetRarityParameterStatusByUserIdRequest()
            .with_namespace_name(self.hash1)
            .with_user_id('user-0001')
            .with_parameter_name('rarity-0001')
            .with_property_id('property-0001')
            .with_parameter_values([
                enchant.RarityParameterValue()
                    .with_name('parameter-0001')
                    .with_resource_name('str')
                    .with_resource_value(100),
                enchant.RarityParameterValue()
                    .with_name('parameter-0002')
                    .with_resource_name('def')
                    .with_resource_value(200),
            ])
            .with_time_offset_token(None)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.set_rarity_parameter_status_by_user_id({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    parameterValues={
        {
            name="parameter-0001",
            resource_name="str",
            resource_value=100,
        },
        {
            name="parameter-0002",
            resource_name="def",
            resource_value=200,
        }
    },
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.set_rarity_parameter_status_by_user_id_async({
    namespaceName="namespace1",
    userId="user-0001",
    parameterName="rarity-0001",
    propertyId="property-0001",
    parameterValues={
        {
            name="parameter-0001",
            resource_name="str",
            resource_value=100,
        },
        {
            name="parameter-0002",
            resource_name="def",
            resource_value=200,
        }
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
old = result.old;

setRarityParameterStatusByStampSheet

Execute setting any value to rarity parameter as a acquire action

Request

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

Result

	Type	Description
item	RarityParameterStatus	Updated rarity parameter status
old	RarityParameterStatus	Rarity parameter status before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/enchant"
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 := enchant.Gs2EnchantRestClient{
    Session: &session,
}
result, err := client.SetRarityParameterStatusByStampSheet(
    &enchant.SetRarityParameterStatusByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Enchant\Gs2EnchantRestClient;
use Gs2\Enchant\Request\SetRarityParameterStatusByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setRarityParameterStatusByStampSheet(
        (new SetRarityParameterStatusByStampSheetRequest())
            ->withStampSheet(self::stampSheet)
            ->withKeyId(self::key-0001)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} 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.enchant.rest.Gs2EnchantRestClient;
import io.gs2.enchant.request.SetRarityParameterStatusByStampSheetRequest;
import io.gs2.enchant.result.SetRarityParameterStatusByStampSheetResult;

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

try {
    SetRarityParameterStatusByStampSheetResult result = client.setRarityParameterStatusByStampSheet(
        new SetRarityParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    RarityParameterStatus item = result.getItem();
    RarityParameterStatus old = result.getOld();
} 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.Gs2Enchant.Gs2EnchantRestClient;
using Gs2.Gs2Enchant.Request.SetRarityParameterStatusByStampSheetRequest;
using Gs2.Gs2Enchant.Result.SetRarityParameterStatusByStampSheetResult;

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

AsyncResult<Gs2.Gs2Enchant.Result.SetRarityParameterStatusByStampSheetResult> asyncResult = null;
yield return client.SetRarityParameterStatusByStampSheet(
    new Gs2.Gs2Enchant.Request.SetRarityParameterStatusByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Enchant from '@/gs2/enchant';

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

try {
    const result = await client.setRarityParameterStatusByStampSheet(
        new Gs2Enchant.SetRarityParameterStatusByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import enchant

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

try:
    result = client.set_rarity_parameter_status_by_stamp_sheet(
        enchant.SetRarityParameterStatusByStampSheetRequest()
            .with_stamp_sheet(self.stamp_sheet)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('enchant')

api_result = client.set_rarity_parameter_status_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

result = api_result.result
item = result.item;
old = result.old;

client = gs2('enchant')

api_result_handler = client.set_rarity_parameter_status_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

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

result = api_result.result
item = result.item;
old = result.old;