GS2-LoginReward SDK API Reference

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

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

client = gs2('login_reward')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
status = result.status;

client = gs2('login_reward')

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

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

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

result = api_result.result
status = result.status;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetNamespaceRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DeleteNamespaceRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetServiceVersionRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

api_result = client.get_service_version({
})

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

api_result_handler = client.get_service_version_async({
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DumpUserDataByUserIdRequest;
import io.gs2.loginReward.result.DumpUserDataByUserIdResult;

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

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

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.DumpUserDataByUserIdResult> asyncResult = null;
yield return client.DumpUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result

client = gs2('login_reward')

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

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

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

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CheckDumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.loginReward.result.CheckDumpUserDataByUserIdResult;

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

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

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.CheckDumpUserDataByUserIdResult> asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
url = result.url;

client = gs2('login_reward')

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

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

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

result = api_result.result
url = result.url;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CleanUserDataByUserIdRequest;
import io.gs2.loginReward.result.CleanUserDataByUserIdResult;

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

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

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.CleanUserDataByUserIdResult> asyncResult = null;
yield return client.CleanUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result

client = gs2('login_reward')

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

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

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

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CheckCleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.loginReward.result.CheckCleanUserDataByUserIdResult;

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

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

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.CheckCleanUserDataByUserIdResult> asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result

client = gs2('login_reward')

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

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

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

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\PrepareImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.loginReward.result.PrepareImportUserDataByUserIdResult;

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

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

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.PrepareImportUserDataByUserIdResult> asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.prepareImportUserDataByUserId(
        new Gs2LoginReward.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 login_reward

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

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

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

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

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

client = gs2('login_reward')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.ImportUserDataByUserIdRequest;
import io.gs2.loginReward.result.ImportUserDataByUserIdResult;

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

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

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.ImportUserDataByUserIdResult> asyncResult = null;
yield return client.ImportUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

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

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

result = api_result.result

client = gs2('login_reward')

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

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

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

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CheckImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CheckImportUserDataByUserIdRequest;
import io.gs2.loginReward.result.CheckImportUserDataByUserIdResult;

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

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

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.CheckImportUserDataByUserIdResult> asyncResult = null;
yield return client.CheckImportUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.checkImportUserDataByUserId(
        new Gs2LoginReward.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 login_reward

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

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

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

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

result = api_result.result
url = result.url;

client = gs2('login_reward')

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

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

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

result = api_result.result
url = result.url;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ReceiveRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.ReceiveRequest;
import io.gs2.loginReward.result.ReceiveResult;

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

try {
    ReceiveResult result = client.receive(
        new ReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withConfig(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.ReceiveResult> asyncResult = null;
yield return client.Receive(
    new Gs2.Gs2LoginReward.Request.ReceiveRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001")
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.receive(
        new Gs2LoginReward.ReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withConfig(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.receive(
        login_reward.ReceiveRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
            .with_config(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.receive({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    config=nil,
})

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

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

client = gs2('login_reward')

api_result_handler = client.receive_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    config=nil,
})

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ReceiveByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.ReceiveByUserIdRequest;
import io.gs2.loginReward.result.ReceiveByUserIdResult;

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

try {
    ReceiveByUserIdResult result = client.receiveByUserId(
        new ReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.ReceiveByUserIdResult> asyncResult = null;
yield return client.ReceiveByUserId(
    new Gs2.Gs2LoginReward.Request.ReceiveByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.receiveByUserId(
        new Gs2LoginReward.ReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.receive_by_user_id(
        login_reward.ReceiveByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.receive_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    config=nil,
    timeOffsetToken=nil,
})

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

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

client = gs2('login_reward')

api_result_handler = client.receive_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    config=nil,
    timeOffsetToken=nil,
})

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MissedReceiveRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->missedReceive(
        (new MissedReceiveRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withAccessToken("accessToken-0001")
            ->withStepNumber(1)
            ->withConfig(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MissedReceiveRequest;
import io.gs2.loginReward.result.MissedReceiveResult;

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

try {
    MissedReceiveResult result = client.missedReceive(
        new MissedReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
            .withConfig(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.MissedReceiveResult> asyncResult = null;
yield return client.MissedReceive(
    new Gs2.Gs2LoginReward.Request.MissedReceiveRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001")
        .WithStepNumber(1)
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.missedReceive(
        new Gs2LoginReward.MissedReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
            .withConfig(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.missed_receive(
        login_reward.MissedReceiveRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
            .with_step_number(1)
            .with_config(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.missed_receive({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
    config=nil,
})

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

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

client = gs2('login_reward')

api_result_handler = client.missed_receive_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
    config=nil,
})

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MissedReceiveByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->missedReceiveByUserId(
        (new MissedReceiveByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withStepNumber(1)
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MissedReceiveByUserIdRequest;
import io.gs2.loginReward.result.MissedReceiveByUserIdResult;

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

try {
    MissedReceiveByUserIdResult result = client.missedReceiveByUserId(
        new MissedReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.MissedReceiveByUserIdResult> asyncResult = null;
yield return client.MissedReceiveByUserId(
    new Gs2.Gs2LoginReward.Request.MissedReceiveByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithStepNumber(1)
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.missedReceiveByUserId(
        new Gs2LoginReward.MissedReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.missed_receive_by_user_id(
        login_reward.MissedReceiveByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_step_number(1)
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.missed_receive_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    config=nil,
    timeOffsetToken=nil,
})

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

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

client = gs2('login_reward')

api_result_handler = client.missed_receive_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    config=nil,
    timeOffsetToken=nil,
})

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeReceiveStatusesRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeReceiveStatusesRequest;
import io.gs2.loginReward.result.DescribeReceiveStatusesResult;

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

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

client = gs2('login_reward')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeReceiveStatusesByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeReceiveStatusesByUserIdRequest;
import io.gs2.loginReward.result.DescribeReceiveStatusesByUserIdResult;

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

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

client = gs2('login_reward')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetReceiveStatusRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getReceiveStatus(
        (new GetReceiveStatusRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withAccessToken("accessToken-0001")
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetReceiveStatusRequest;
import io.gs2.loginReward.result.GetReceiveStatusResult;

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

try {
    GetReceiveStatusResult result = client.getReceiveStatus(
        new GetReceiveStatusRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.GetReceiveStatusResult> asyncResult = null;
yield return client.GetReceiveStatus(
    new Gs2.Gs2LoginReward.Request.GetReceiveStatusRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getReceiveStatus(
        new Gs2LoginReward.GetReceiveStatusRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_receive_status(
        login_reward.GetReceiveStatusRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.get_receive_status({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

client = gs2('login_reward')

api_result_handler = client.get_receive_status_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
})

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetReceiveStatusByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getReceiveStatusByUserId(
        (new GetReceiveStatusByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetReceiveStatusByUserIdRequest;
import io.gs2.loginReward.result.GetReceiveStatusByUserIdResult;

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

try {
    GetReceiveStatusByUserIdResult result = client.getReceiveStatusByUserId(
        new GetReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.GetReceiveStatusByUserIdResult> asyncResult = null;
yield return client.GetReceiveStatusByUserId(
    new Gs2.Gs2LoginReward.Request.GetReceiveStatusByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getReceiveStatusByUserId(
        new Gs2LoginReward.GetReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_receive_status_by_user_id(
        login_reward.GetReceiveStatusByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.get_receive_status_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

client = gs2('login_reward')

api_result_handler = client.get_receive_status_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DeleteReceiveStatusByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->deleteReceiveStatusByUserId(
        (new DeleteReceiveStatusByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DeleteReceiveStatusByUserIdRequest;
import io.gs2.loginReward.result.DeleteReceiveStatusByUserIdResult;

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

try {
    DeleteReceiveStatusByUserIdResult result = client.deleteReceiveStatusByUserId(
        new DeleteReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.DeleteReceiveStatusByUserIdResult> asyncResult = null;
yield return client.DeleteReceiveStatusByUserId(
    new Gs2.Gs2LoginReward.Request.DeleteReceiveStatusByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.deleteReceiveStatusByUserId(
        new Gs2LoginReward.DeleteReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.delete_receive_status_by_user_id(
        login_reward.DeleteReceiveStatusByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.delete_receive_status_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

client = gs2('login_reward')

api_result_handler = client.delete_receive_status_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MarkReceivedRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->markReceived(
        (new MarkReceivedRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withAccessToken("accessToken-0001")
            ->withStepNumber(1)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MarkReceivedRequest;
import io.gs2.loginReward.result.MarkReceivedResult;

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

try {
    MarkReceivedResult result = client.markReceived(
        new MarkReceivedRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.MarkReceivedResult> asyncResult = null;
yield return client.MarkReceived(
    new Gs2.Gs2LoginReward.Request.MarkReceivedRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001")
        .WithStepNumber(1),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.markReceived(
        new Gs2LoginReward.MarkReceivedRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.mark_received(
        login_reward.MarkReceivedRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
            .with_step_number(1)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.mark_received({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

client = gs2('login_reward')

api_result_handler = client.mark_received_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
})

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MarkReceivedByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->markReceivedByUserId(
        (new MarkReceivedByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withStepNumber(1)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MarkReceivedByUserIdRequest;
import io.gs2.loginReward.result.MarkReceivedByUserIdResult;

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

try {
    MarkReceivedByUserIdResult result = client.markReceivedByUserId(
        new MarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.MarkReceivedByUserIdResult> asyncResult = null;
yield return client.MarkReceivedByUserId(
    new Gs2.Gs2LoginReward.Request.MarkReceivedByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithStepNumber(1)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.markReceivedByUserId(
        new Gs2LoginReward.MarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.mark_received_by_user_id(
        login_reward.MarkReceivedByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_step_number(1)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.mark_received_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

client = gs2('login_reward')

api_result_handler = client.mark_received_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UnmarkReceivedByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->unmarkReceivedByUserId(
        (new UnmarkReceivedByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withStepNumber(1)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UnmarkReceivedByUserIdRequest;
import io.gs2.loginReward.result.UnmarkReceivedByUserIdResult;

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

try {
    UnmarkReceivedByUserIdResult result = client.unmarkReceivedByUserId(
        new UnmarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.UnmarkReceivedByUserIdResult> asyncResult = null;
yield return client.UnmarkReceivedByUserId(
    new Gs2.Gs2LoginReward.Request.UnmarkReceivedByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithStepNumber(1)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.unmarkReceivedByUserId(
        new Gs2LoginReward.UnmarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.unmark_received_by_user_id(
        login_reward.UnmarkReceivedByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_step_number(1)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.unmark_received_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

client = gs2('login_reward')

api_result_handler = client.unmark_received_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeBonusModelsRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeBonusModelsRequest;
import io.gs2.loginReward.result.DescribeBonusModelsResult;

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

try {
    DescribeBonusModelsResult result = client.describeBonusModels(
        new DescribeBonusModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<BonusModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.describe_bonus_models(
        login_reward.DescribeBonusModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

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

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

result = api_result.result
items = result.items;

client = gs2('login_reward')

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

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

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

result = api_result.result
items = result.items;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetBonusModelRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getBonusModel(
        (new GetBonusModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetBonusModelRequest;
import io.gs2.loginReward.result.GetBonusModelResult;

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

try {
    GetBonusModelResult result = client.getBonusModel(
        new GetBonusModelRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
    );
    BonusModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.GetBonusModelResult> asyncResult = null;
yield return client.GetBonusModel(
    new Gs2.Gs2LoginReward.Request.GetBonusModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getBonusModel(
        new Gs2LoginReward.GetBonusModelRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_bonus_model(
        login_reward.GetBonusModelRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.get_bonus_model({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

api_result_handler = client.get_bonus_model_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ExportMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetCurrentBonusMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetCurrentBonusMasterRequest;
import io.gs2.loginReward.result.GetCurrentBonusMasterResult;

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

try {
    GetCurrentBonusMasterResult result = client.getCurrentBonusMaster(
        new GetCurrentBonusMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentBonusMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_current_bonus_master(
        login_reward.GetCurrentBonusMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\PreUpdateCurrentBonusMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.PreUpdateCurrentBonusMasterRequest;
import io.gs2.loginReward.result.PreUpdateCurrentBonusMasterResult;

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.pre_update_current_bonus_master(
        login_reward.PreUpdateCurrentBonusMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

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

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

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

client = gs2('login_reward')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateCurrentBonusMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->updateCurrentBonusMaster(
        (new UpdateCurrentBonusMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
            ->withUploadToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UpdateCurrentBonusMasterRequest;
import io.gs2.loginReward.result.UpdateCurrentBonusMasterResult;

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

try {
    UpdateCurrentBonusMasterResult result = client.updateCurrentBonusMaster(
        new UpdateCurrentBonusMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
            .withUploadToken(null)
    );
    CurrentBonusMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.UpdateCurrentBonusMasterResult> asyncResult = null;
yield return client.UpdateCurrentBonusMaster(
    new Gs2.Gs2LoginReward.Request.UpdateCurrentBonusMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
        .WithUploadToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.updateCurrentBonusMaster(
        new Gs2LoginReward.UpdateCurrentBonusMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.update_current_bonus_master(
        login_reward.UpdateCurrentBonusMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{"version": "2023-07-11", "bonusModels": [{"name": "schedule", "mode": "schedule", "periodEventId": "grn:gs2:schedule:grn-0001", "rewards": [{"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}], "missedReceiveRelief": "disabled"}, {"name": "streaming", "mode": "streaming", "resetHour": 15, "repeat": "enabled", "rewards": [{"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}], "missedReceiveRelief": "enabled", "missedReceiveReliefConsumeActions": [{"action": "Gs2Money:WithdrawByUserId", "request": {"namespaceName": "money-0001", "userId": "#{userId}", "slot": 0, "count": 200, "paidOnly": false}}]}]}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.update_current_bonus_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}",
    uploadToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

api_result_handler = client.update_current_bonus_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}",
    uploadToken=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateCurrentBonusMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UpdateCurrentBonusMasterFromGitHubRequest;
import io.gs2.loginReward.result.UpdateCurrentBonusMasterFromGitHubResult;

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeBonusModelMastersRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeBonusModelMastersRequest;
import io.gs2.loginReward.result.DescribeBonusModelMastersResult;

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

from gs2 import core
from gs2 import login_reward

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

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

client = gs2('login_reward')

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

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

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

client = gs2('login_reward')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CreateBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->createBonusModelMaster(
        (new CreateBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("bonusModel-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withMode("schedule")
            ->withPeriodEventId("grn:gs2:schedule:grn-0001")
            ->withResetHour(null)
            ->withRepeat(null)
            ->withRewards([
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            ->withMissedReceiveRelief("disabled")
            ->withMissedReceiveReliefVerifyActions(null)
            ->withMissedReceiveReliefConsumeActions(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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CreateBonusModelMasterRequest;
import io.gs2.loginReward.result.CreateBonusModelMasterResult;

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

try {
    CreateBonusModelMasterResult result = client.createBonusModelMaster(
        new CreateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("bonusModel-0001")
            .withDescription(null)
            .withMetadata(null)
            .withMode("schedule")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat(null)
            .withRewards(Arrays.asList(
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    ))
            ))
            .withMissedReceiveRelief("disabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions(null)
    );
    BonusModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.CreateBonusModelMasterResult> asyncResult = null;
yield return client.CreateBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.CreateBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("bonusModel-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithMode("schedule")
        .WithPeriodEventId("grn:gs2:schedule:grn-0001")
        .WithResetHour(null)
        .WithRepeat(null)
        .WithRewards(new Gs2.Gs2LoginReward.Model.Reward[] {
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
        })
        .WithMissedReceiveRelief("disabled")
        .WithMissedReceiveReliefVerifyActions(null)
        .WithMissedReceiveReliefConsumeActions(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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.createBonusModelMaster(
        new Gs2LoginReward.CreateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("bonusModel-0001")
            .withDescription(null)
            .withMetadata(null)
            .withMode("schedule")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat(null)
            .withRewards([
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            .withMissedReceiveRelief("disabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.create_bonus_model_master(
        login_reward.CreateBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('bonusModel-0001')
            .with_description(None)
            .with_metadata(None)
            .with_mode('schedule')
            .with_period_event_id('grn:gs2:schedule:grn-0001')
            .with_reset_hour(None)
            .with_repeat(None)
            .with_rewards([
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
            ])
            .with_missed_receive_relief('disabled')
            .with_missed_receive_relief_verify_actions(None)
            .with_missed_receive_relief_consume_actions(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.create_bonus_model_master({
    namespaceName="namespace-0001",
    name="bonusModel-0001",
    description=nil,
    metadata=nil,
    mode="schedule",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat=nil,
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="disabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

api_result_handler = client.create_bonus_model_master_async({
    namespaceName="namespace-0001",
    name="bonusModel-0001",
    description=nil,
    metadata=nil,
    mode="schedule",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat=nil,
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="disabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getBonusModelMaster(
        (new GetBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonusModel-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetBonusModelMasterRequest;
import io.gs2.loginReward.result.GetBonusModelMasterResult;

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

try {
    GetBonusModelMasterResult result = client.getBonusModelMaster(
        new GetBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    BonusModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.GetBonusModelMasterResult> asyncResult = null;
yield return client.GetBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.GetBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonusModel-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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getBonusModelMaster(
        new Gs2LoginReward.GetBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_bonus_model_master(
        login_reward.GetBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonusModel-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.get_bonus_model_master({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

api_result_handler = client.get_bonus_model_master_async({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->updateBonusModelMaster(
        (new UpdateBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonusModel-0001")
            ->withDescription("description1")
            ->withMetadata(null)
            ->withMode("streaming")
            ->withPeriodEventId("grn:gs2:schedule:grn-0001")
            ->withResetHour(null)
            ->withRepeat("disabled")
            ->withRewards([
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            ->withMissedReceiveRelief("enabled")
            ->withMissedReceiveReliefVerifyActions(null)
            ->withMissedReceiveReliefConsumeActions([
                (new \Gs2\LoginReward\Model\ConsumeAction())
                    ->withAction("Gs2Money:WithdrawByUserId")
                    ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
            ])
    );
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UpdateBonusModelMasterRequest;
import io.gs2.loginReward.result.UpdateBonusModelMasterResult;

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

try {
    UpdateBonusModelMasterResult result = client.updateBonusModelMaster(
        new UpdateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withMode("streaming")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat("disabled")
            .withRewards(Arrays.asList(
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    ))
            ))
            .withMissedReceiveRelief("enabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions(Arrays.asList(
                new io.gs2.loginReward.model.ConsumeAction()
                    .withAction("Gs2Money:WithdrawByUserId")
                    .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}")
            ))
    );
    BonusModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.UpdateBonusModelMasterResult> asyncResult = null;
yield return client.UpdateBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.UpdateBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonusModel-0001")
        .WithDescription("description1")
        .WithMetadata(null)
        .WithMode("streaming")
        .WithPeriodEventId("grn:gs2:schedule:grn-0001")
        .WithResetHour(null)
        .WithRepeat("disabled")
        .WithRewards(new Gs2.Gs2LoginReward.Model.Reward[] {
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
        })
        .WithMissedReceiveRelief("enabled")
        .WithMissedReceiveReliefVerifyActions(null)
        .WithMissedReceiveReliefConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Money:WithdrawByUserId")
                .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
        }),
    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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.updateBonusModelMaster(
        new Gs2LoginReward.UpdateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withMode("streaming")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat("disabled")
            .withRewards([
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            .withMissedReceiveRelief("enabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions([
                new Gs2LoginReward.model.ConsumeAction()
                    .withAction("Gs2Money:WithdrawByUserId")
                    .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.update_bonus_model_master(
        login_reward.UpdateBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonusModel-0001')
            .with_description('description1')
            .with_metadata(None)
            .with_mode('streaming')
            .with_period_event_id('grn:gs2:schedule:grn-0001')
            .with_reset_hour(None)
            .with_repeat('disabled')
            .with_rewards([
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
            ])
            .with_missed_receive_relief('enabled')
            .with_missed_receive_relief_verify_actions(None)
            .with_missed_receive_relief_consume_actions([
                login_reward.ConsumeAction()
                    .with_action('Gs2Money:WithdrawByUserId')
                    .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.update_bonus_model_master({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
    description="description1",
    metadata=nil,
    mode="streaming",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat="disabled",
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="enabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions={
        {
            action="Gs2Money:WithdrawByUserId",
            request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
        }
    },
})

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

api_result_handler = client.update_bonus_model_master_async({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
    description="description1",
    metadata=nil,
    mode="streaming",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat="disabled",
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="enabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions={
        {
            action="Gs2Money:WithdrawByUserId",
            request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
        }
    },
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DeleteBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->deleteBonusModelMaster(
        (new DeleteBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonusModel-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DeleteBonusModelMasterRequest;
import io.gs2.loginReward.result.DeleteBonusModelMasterResult;

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

try {
    DeleteBonusModelMasterResult result = client.deleteBonusModelMaster(
        new DeleteBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    BonusModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2LoginReward.Result.DeleteBonusModelMasterResult> asyncResult = null;
yield return client.DeleteBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.DeleteBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonusModel-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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.deleteBonusModelMaster(
        new Gs2LoginReward.DeleteBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.delete_bonus_model_master(
        login_reward.DeleteBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonusModel-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('login_reward')

api_result = client.delete_bonus_model_master({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('login_reward')

api_result_handler = client.delete_bonus_model_master_async({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
})

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

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

result = api_result.result
item = result.item;