GS2-SeasonRating SDK API リファレンス

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.DescribeNamespacesRequest;
import io.gs2.seasonRating.result.DescribeNamespacesResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

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

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

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName("namespace-0001")
            ->withDescription(null)
            ->withTransactionSetting(null)
            ->withLogSetting((new \Gs2\SeasonRating\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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.CreateNamespaceRequest;
import io.gs2.seasonRating.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(null)
            .withLogSetting(new io.gs2.seasonRating.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 Gs2SeasonRatingRestClient(session);

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

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

try {
    const result = await client.createNamespace(
        new Gs2SeasonRating.CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(null)
            .withLogSetting(new Gs2SeasonRating.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 season_rating

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

try:
    result = client.create_namespace(
        season_rating.CreateNamespaceRequest()
            .with_name('namespace-0001')
            .with_description(None)
            .with_transaction_setting(None)
            .with_log_setting(
                season_rating.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('season_rating')

api_result = client.create_namespace({
    name="namespace-0001",
    description=nil,
    transactionSetting=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('season_rating')

api_result_handler = client.create_namespace_async({
    name="namespace-0001",
    description=nil,
    transactionSetting=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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetNamespaceStatusRequest;
import io.gs2.seasonRating.result.GetNamespaceStatusResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetNamespaceRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetNamespaceRequest;
import io.gs2.seasonRating.result.GetNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName("namespace-0001")
            ->withDescription("description1")
            ->withTransactionSetting(null)
            ->withLogSetting((new \Gs2\SeasonRating\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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.UpdateNamespaceRequest;
import io.gs2.seasonRating.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(null)
            .withLogSetting(new io.gs2.seasonRating.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 Gs2SeasonRatingRestClient(session);

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

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

try {
    const result = await client.updateNamespace(
        new Gs2SeasonRating.UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(null)
            .withLogSetting(new Gs2SeasonRating.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 season_rating

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

try:
    result = client.update_namespace(
        season_rating.UpdateNamespaceRequest()
            .with_namespace_name('namespace-0001')
            .with_description('description1')
            .with_transaction_setting(None)
            .with_log_setting(
                season_rating.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('season_rating')

api_result = client.update_namespace({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting=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('season_rating')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting=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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DeleteNamespaceRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.DeleteNamespaceRequest;
import io.gs2.seasonRating.result.DeleteNamespaceResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetServiceVersionRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetServiceVersionRequest;
import io.gs2.seasonRating.result.GetServiceVersionResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.GetServiceVersionResult> asyncResult = null;
yield return client.GetServiceVersion(
    new Gs2.Gs2SeasonRating.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 Gs2SeasonRating from '@/gs2/seasonRating';

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DumpUserDataByUserIdRequest;

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

$session->open();

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

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CheckDumpUserDataByUserIdRequest;

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

$session->open();

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

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CleanUserDataByUserIdRequest;

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

$session->open();

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

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CheckCleanUserDataByUserIdRequest;

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

$session->open();

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

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\PrepareImportUserDataByUserIdRequest;

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

$session->open();

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

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

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

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

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\ImportUserDataByUserIdRequest;

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

$session->open();

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

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CheckImportUserDataByUserIdRequest;

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

$session->open();

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

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    )
);
session.connect();
Gs2SeasonRatingRestClient client = new Gs2SeasonRatingRestClient(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 Gs2SeasonRatingRestClient(session);

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

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

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

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

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

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DescribeMatchSessionsRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->describeMatchSessions(
        (new DescribeMatchSessionsRequest())
            ->withNamespaceName("namespace-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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.DescribeMatchSessionsRequest;
import io.gs2.seasonRating.result.DescribeMatchSessionsResult;

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

try {
    DescribeMatchSessionsResult result = client.describeMatchSessions(
        new DescribeMatchSessionsRequest()
            .withNamespaceName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<MatchSession> 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.DescribeMatchSessionsResult> asyncResult = null;
yield return client.DescribeMatchSessions(
    new Gs2.Gs2SeasonRating.Request.DescribeMatchSessionsRequest()
        .WithNamespaceName("namespace-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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.describeMatchSessions(
        new Gs2SeasonRating.DescribeMatchSessionsRequest()
            .withNamespaceName("namespace-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 season_rating

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

try:
    result = client.describe_match_sessions(
        season_rating.DescribeMatchSessionsRequest()
            .with_namespace_name('namespace-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('season_rating')

api_result = client.describe_match_sessions({
    namespaceName="namespace-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('season_rating')

api_result_handler = client.describe_match_sessions_async({
    namespaceName="namespace-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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CreateMatchSessionRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->createMatchSession(
        (new CreateMatchSessionRequest())
            ->withNamespaceName("namespace-0001")
            ->withSessionName("matchSession-0001")
            ->withTtlSeconds(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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.CreateMatchSessionRequest;
import io.gs2.seasonRating.result.CreateMatchSessionResult;

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

try {
    CreateMatchSessionResult result = client.createMatchSession(
        new CreateMatchSessionRequest()
            .withNamespaceName("namespace-0001")
            .withSessionName("matchSession-0001")
            .withTtlSeconds(null)
    );
    MatchSession 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.CreateMatchSessionResult> asyncResult = null;
yield return client.CreateMatchSession(
    new Gs2.Gs2SeasonRating.Request.CreateMatchSessionRequest()
        .WithNamespaceName("namespace-0001")
        .WithSessionName("matchSession-0001")
        .WithTtlSeconds(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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.createMatchSession(
        new Gs2SeasonRating.CreateMatchSessionRequest()
            .withNamespaceName("namespace-0001")
            .withSessionName("matchSession-0001")
            .withTtlSeconds(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.create_match_session(
        season_rating.CreateMatchSessionRequest()
            .with_namespace_name('namespace-0001')
            .with_session_name('matchSession-0001')
            .with_ttl_seconds(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.create_match_session({
    namespaceName="namespace-0001",
    sessionName="matchSession-0001",
    ttlSeconds=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('season_rating')

api_result_handler = client.create_match_session_async({
    namespaceName="namespace-0001",
    sessionName="matchSession-0001",
    ttlSeconds=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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetMatchSessionRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->getMatchSession(
        (new GetMatchSessionRequest())
            ->withNamespaceName("namespace-0001")
            ->withSessionName("matchSession-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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetMatchSessionRequest;
import io.gs2.seasonRating.result.GetMatchSessionResult;

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

try {
    GetMatchSessionResult result = client.getMatchSession(
        new GetMatchSessionRequest()
            .withNamespaceName("namespace-0001")
            .withSessionName("matchSession-0001")
    );
    MatchSession 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.GetMatchSessionResult> asyncResult = null;
yield return client.GetMatchSession(
    new Gs2.Gs2SeasonRating.Request.GetMatchSessionRequest()
        .WithNamespaceName("namespace-0001")
        .WithSessionName("matchSession-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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.getMatchSession(
        new Gs2SeasonRating.GetMatchSessionRequest()
            .withNamespaceName("namespace-0001")
            .withSessionName("matchSession-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.get_match_session(
        season_rating.GetMatchSessionRequest()
            .with_namespace_name('namespace-0001')
            .with_session_name('matchSession-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.get_match_session({
    namespaceName="namespace-0001",
    sessionName="matchSession-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('season_rating')

api_result_handler = client.get_match_session_async({
    namespaceName="namespace-0001",
    sessionName="matchSession-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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DeleteMatchSessionRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->deleteMatchSession(
        (new DeleteMatchSessionRequest())
            ->withNamespaceName("namespace-0001")
            ->withSessionName("matchSession-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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.DeleteMatchSessionRequest;
import io.gs2.seasonRating.result.DeleteMatchSessionResult;

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

try {
    DeleteMatchSessionResult result = client.deleteMatchSession(
        new DeleteMatchSessionRequest()
            .withNamespaceName("namespace-0001")
            .withSessionName("matchSession-0001")
    );
    MatchSession 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.DeleteMatchSessionResult> asyncResult = null;
yield return client.DeleteMatchSession(
    new Gs2.Gs2SeasonRating.Request.DeleteMatchSessionRequest()
        .WithNamespaceName("namespace-0001")
        .WithSessionName("matchSession-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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.deleteMatchSession(
        new Gs2SeasonRating.DeleteMatchSessionRequest()
            .withNamespaceName("namespace-0001")
            .withSessionName("matchSession-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.delete_match_session(
        season_rating.DeleteMatchSessionRequest()
            .with_namespace_name('namespace-0001')
            .with_session_name('matchSession-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.delete_match_session({
    namespaceName="namespace-0001",
    sessionName="matchSession-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('season_rating')

api_result_handler = client.delete_match_session_async({
    namespaceName="namespace-0001",
    sessionName="matchSession-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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetBallotRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->getBallot(
        (new GetBallotRequest())
            ->withNamespaceName("namespace-0001")
            ->withSeasonName("season-0001")
            ->withSessionName("gathering-0001")
            ->withAccessToken("accessToken-0001")
            ->withNumberOfPlayer(4)
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $body = $result->getBody();
    $signature = $result->getSignature();
} 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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetBallotRequest;
import io.gs2.seasonRating.result.GetBallotResult;

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

try {
    GetBallotResult result = client.getBallot(
        new GetBallotRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("season-0001")
            .withSessionName("gathering-0001")
            .withAccessToken("accessToken-0001")
            .withNumberOfPlayer(4)
            .withKeyId("key-0001")
    );
    Ballot item = result.getItem();
    String body = result.getBody();
    String signature = result.getSignature();
} 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.GetBallotResult> asyncResult = null;
yield return client.GetBallot(
    new Gs2.Gs2SeasonRating.Request.GetBallotRequest()
        .WithNamespaceName("namespace-0001")
        .WithSeasonName("season-0001")
        .WithSessionName("gathering-0001")
        .WithAccessToken("accessToken-0001")
        .WithNumberOfPlayer(4)
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var body = result.Body;
var signature = result.Signature;

import Gs2Core from '@/gs2/core';
import * as Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.getBallot(
        new Gs2SeasonRating.GetBallotRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("season-0001")
            .withSessionName("gathering-0001")
            .withAccessToken("accessToken-0001")
            .withNumberOfPlayer(4)
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const body = result.getBody();
    const signature = result.getSignature();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.get_ballot(
        season_rating.GetBallotRequest()
            .with_namespace_name('namespace-0001')
            .with_season_name('season-0001')
            .with_session_name('gathering-0001')
            .with_access_token('accessToken-0001')
            .with_number_of_player(4)
            .with_key_id('key-0001')
    )
    item = result.item
    body = result.body
    signature = result.signature
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.get_ballot({
    namespaceName="namespace-0001",
    seasonName="season-0001",
    sessionName="gathering-0001",
    accessToken="accessToken-0001",
    numberOfPlayer=4,
    keyId="key-0001",
})

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

result = api_result.result
item = result.item;
body = result.body;
signature = result.signature;

client = gs2('season_rating')

api_result_handler = client.get_ballot_async({
    namespaceName="namespace-0001",
    seasonName="season-0001",
    sessionName="gathering-0001",
    accessToken="accessToken-0001",
    numberOfPlayer=4,
    keyId="key-0001",
})

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

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

result = api_result.result
item = result.item;
body = result.body;
signature = result.signature;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetBallotByUserIdRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->getBallotByUserId(
        (new GetBallotByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withSeasonName("season-0001")
            ->withSessionName("gathering-0001")
            ->withUserId("user-0001")
            ->withNumberOfPlayer(4)
            ->withKeyId("key-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $body = $result->getBody();
    $signature = $result->getSignature();
} 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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetBallotByUserIdRequest;
import io.gs2.seasonRating.result.GetBallotByUserIdResult;

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

try {
    GetBallotByUserIdResult result = client.getBallotByUserId(
        new GetBallotByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("season-0001")
            .withSessionName("gathering-0001")
            .withUserId("user-0001")
            .withNumberOfPlayer(4)
            .withKeyId("key-0001")
            .withTimeOffsetToken(null)
    );
    Ballot item = result.getItem();
    String body = result.getBody();
    String signature = result.getSignature();
} 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.GetBallotByUserIdResult> asyncResult = null;
yield return client.GetBallotByUserId(
    new Gs2.Gs2SeasonRating.Request.GetBallotByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithSeasonName("season-0001")
        .WithSessionName("gathering-0001")
        .WithUserId("user-0001")
        .WithNumberOfPlayer(4)
        .WithKeyId("key-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var body = result.Body;
var signature = result.Signature;

import Gs2Core from '@/gs2/core';
import * as Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.getBallotByUserId(
        new Gs2SeasonRating.GetBallotByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("season-0001")
            .withSessionName("gathering-0001")
            .withUserId("user-0001")
            .withNumberOfPlayer(4)
            .withKeyId("key-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const body = result.getBody();
    const signature = result.getSignature();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.get_ballot_by_user_id(
        season_rating.GetBallotByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_season_name('season-0001')
            .with_session_name('gathering-0001')
            .with_user_id('user-0001')
            .with_number_of_player(4)
            .with_key_id('key-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    body = result.body
    signature = result.signature
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.get_ballot_by_user_id({
    namespaceName="namespace-0001",
    seasonName="season-0001",
    sessionName="gathering-0001",
    userId="user-0001",
    numberOfPlayer=4,
    keyId="key-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;
body = result.body;
signature = result.signature;

client = gs2('season_rating')

api_result_handler = client.get_ballot_by_user_id_async({
    namespaceName="namespace-0001",
    seasonName="season-0001",
    sessionName="gathering-0001",
    userId="user-0001",
    numberOfPlayer=4,
    keyId="key-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;
body = result.body;
signature = result.signature;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\VoteRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->vote(
        (new VoteRequest())
            ->withNamespaceName("namespace-0001")
            ->withBallotBody("ballotBody...")
            ->withBallotSignature("ballotSignature...")
            ->withGameResults([
                (new GameResult())
                    ->withRank(1)
                    ->withUserId("user-0001"),
                (new GameResult())
                    ->withRank(2)
                    ->withUserId("user-0002"),
                (new GameResult())
                    ->withRank(2)
                    ->withUserId("user-0003"),
                (new GameResult())
                    ->withRank(3)
                    ->withUserId("user-0004"),
            ])
            ->withKeyId("key-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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.VoteRequest;
import io.gs2.seasonRating.result.VoteResult;

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

try {
    VoteResult result = client.vote(
        new VoteRequest()
            .withNamespaceName("namespace-0001")
            .withBallotBody("ballotBody...")
            .withBallotSignature("ballotSignature...")
            .withGameResults(Arrays.asList(
                new GameResult()
                    .withRank(1)
                    .withUserId("user-0001"),
                new GameResult()
                    .withRank(2)
                    .withUserId("user-0002"),
                new GameResult()
                    .withRank(2)
                    .withUserId("user-0003"),
                new GameResult()
                    .withRank(3)
                    .withUserId("user-0004")
            ))
            .withKeyId("key-0001")
    );
    Ballot 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.VoteResult> asyncResult = null;
yield return client.Vote(
    new Gs2.Gs2SeasonRating.Request.VoteRequest()
        .WithNamespaceName("namespace-0001")
        .WithBallotBody("ballotBody...")
        .WithBallotSignature("ballotSignature...")
        .WithGameResults(new Gs2.Gs2SeasonRating.Model.GameResult[] {
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(1)
                .WithUserId("user-0001"),
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(2)
                .WithUserId("user-0002"),
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(2)
                .WithUserId("user-0003"),
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(3)
                .WithUserId("user-0004"),
        })
        .WithKeyId("key-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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.vote(
        new Gs2SeasonRating.VoteRequest()
            .withNamespaceName("namespace-0001")
            .withBallotBody("ballotBody...")
            .withBallotSignature("ballotSignature...")
            .withGameResults([
                new Gs2SeasonRating.model.GameResult()
                    .withRank(1)
                    .withUserId("user-0001"),
                new Gs2SeasonRating.model.GameResult()
                    .withRank(2)
                    .withUserId("user-0002"),
                new Gs2SeasonRating.model.GameResult()
                    .withRank(2)
                    .withUserId("user-0003"),
                new Gs2SeasonRating.model.GameResult()
                    .withRank(3)
                    .withUserId("user-0004"),
            ])
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.vote(
        season_rating.VoteRequest()
            .with_namespace_name('namespace-0001')
            .with_ballot_body('ballotBody...')
            .with_ballot_signature('ballotSignature...')
            .with_game_results([
                season_rating.GameResult()
                    .with_rank(1)
                    .with_user_id('user-0001'),
                season_rating.GameResult()
                    .with_rank(2)
                    .with_user_id('user-0002'),
                season_rating.GameResult()
                    .with_rank(2)
                    .with_user_id('user-0003'),
                season_rating.GameResult()
                    .with_rank(3)
                    .with_user_id('user-0004'),
            ])
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.vote({
    namespaceName="namespace-0001",
    ballotBody="ballotBody...",
    ballotSignature="ballotSignature...",
    gameResults={
        {
            rank=1,
            user_id="user-0001",
        },
        {
            rank=2,
            user_id="user-0002",
        },
        {
            rank=2,
            user_id="user-0003",
        },
        {
            rank=3,
            user_id="user-0004",
        }
    },
    keyId="key-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('season_rating')

api_result_handler = client.vote_async({
    namespaceName="namespace-0001",
    ballotBody="ballotBody...",
    ballotSignature="ballotSignature...",
    gameResults={
        {
            rank=1,
            user_id="user-0001",
        },
        {
            rank=2,
            user_id="user-0002",
        },
        {
            rank=2,
            user_id="user-0003",
        },
        {
            rank=3,
            user_id="user-0004",
        }
    },
    keyId="key-0001",
})

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

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\VoteMultipleRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->voteMultiple(
        (new VoteMultipleRequest())
            ->withNamespaceName("namespace-0001")
            ->withSignedBallots([
                (new SignedBallot())
                    ->withBody("aaa")
                    ->withSignature("bbb"),
                (new SignedBallot())
                    ->withBody("aaa")
                    ->withSignature("bbb"),
                (new SignedBallot())
                    ->withBody("aaa")
                    ->withSignature("bbb"),
                (new SignedBallot())
                    ->withBody("aaa")
                    ->withSignature("bbb"),
            ])
            ->withGameResults([
                (new GameResult())
                    ->withRank(1)
                    ->withUserId("user-0001"),
                (new GameResult())
                    ->withRank(2)
                    ->withUserId("user-0002"),
                (new GameResult())
                    ->withRank(2)
                    ->withUserId("user-0003"),
                (new GameResult())
                    ->withRank(3)
                    ->withUserId("user-0004"),
            ])
            ->withKeyId("key-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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.VoteMultipleRequest;
import io.gs2.seasonRating.result.VoteMultipleResult;

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

try {
    VoteMultipleResult result = client.voteMultiple(
        new VoteMultipleRequest()
            .withNamespaceName("namespace-0001")
            .withSignedBallots(Arrays.asList(
                new SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb"),
                new SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb"),
                new SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb"),
                new SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb")
            ))
            .withGameResults(Arrays.asList(
                new GameResult()
                    .withRank(1)
                    .withUserId("user-0001"),
                new GameResult()
                    .withRank(2)
                    .withUserId("user-0002"),
                new GameResult()
                    .withRank(2)
                    .withUserId("user-0003"),
                new GameResult()
                    .withRank(3)
                    .withUserId("user-0004")
            ))
            .withKeyId("key-0001")
    );
    Ballot 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.VoteMultipleResult> asyncResult = null;
yield return client.VoteMultiple(
    new Gs2.Gs2SeasonRating.Request.VoteMultipleRequest()
        .WithNamespaceName("namespace-0001")
        .WithSignedBallots(new Gs2.Gs2SeasonRating.Model.SignedBallot[] {
            new Gs2.Gs2SeasonRating.Model.SignedBallot()
                .WithBody("aaa")
                .WithSignature("bbb"),
            new Gs2.Gs2SeasonRating.Model.SignedBallot()
                .WithBody("aaa")
                .WithSignature("bbb"),
            new Gs2.Gs2SeasonRating.Model.SignedBallot()
                .WithBody("aaa")
                .WithSignature("bbb"),
            new Gs2.Gs2SeasonRating.Model.SignedBallot()
                .WithBody("aaa")
                .WithSignature("bbb"),
        })
        .WithGameResults(new Gs2.Gs2SeasonRating.Model.GameResult[] {
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(1)
                .WithUserId("user-0001"),
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(2)
                .WithUserId("user-0002"),
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(2)
                .WithUserId("user-0003"),
            new Gs2.Gs2SeasonRating.Model.GameResult()
                .WithRank(3)
                .WithUserId("user-0004"),
        })
        .WithKeyId("key-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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.voteMultiple(
        new Gs2SeasonRating.VoteMultipleRequest()
            .withNamespaceName("namespace-0001")
            .withSignedBallots([
                new Gs2SeasonRating.model.SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb"),
                new Gs2SeasonRating.model.SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb"),
                new Gs2SeasonRating.model.SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb"),
                new Gs2SeasonRating.model.SignedBallot()
                    .withBody("aaa")
                    .withSignature("bbb"),
            ])
            .withGameResults([
                new Gs2SeasonRating.model.GameResult()
                    .withRank(1)
                    .withUserId("user-0001"),
                new Gs2SeasonRating.model.GameResult()
                    .withRank(2)
                    .withUserId("user-0002"),
                new Gs2SeasonRating.model.GameResult()
                    .withRank(2)
                    .withUserId("user-0003"),
                new Gs2SeasonRating.model.GameResult()
                    .withRank(3)
                    .withUserId("user-0004"),
            ])
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.vote_multiple(
        season_rating.VoteMultipleRequest()
            .with_namespace_name('namespace-0001')
            .with_signed_ballots([
                season_rating.SignedBallot()
                    .with_body('aaa')
                    .with_signature('bbb'),
                season_rating.SignedBallot()
                    .with_body('aaa')
                    .with_signature('bbb'),
                season_rating.SignedBallot()
                    .with_body('aaa')
                    .with_signature('bbb'),
                season_rating.SignedBallot()
                    .with_body('aaa')
                    .with_signature('bbb'),
            ])
            .with_game_results([
                season_rating.GameResult()
                    .with_rank(1)
                    .with_user_id('user-0001'),
                season_rating.GameResult()
                    .with_rank(2)
                    .with_user_id('user-0002'),
                season_rating.GameResult()
                    .with_rank(2)
                    .with_user_id('user-0003'),
                season_rating.GameResult()
                    .with_rank(3)
                    .with_user_id('user-0004'),
            ])
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.vote_multiple({
    namespaceName="namespace-0001",
    signedBallots={
        {
            body="aaa",
            signature="bbb",
        },
        {
            body="aaa",
            signature="bbb",
        },
        {
            body="aaa",
            signature="bbb",
        },
        {
            body="aaa",
            signature="bbb",
        }
    },
    gameResults={
        {
            rank=1,
            user_id="user-0001",
        },
        {
            rank=2,
            user_id="user-0002",
        },
        {
            rank=2,
            user_id="user-0003",
        },
        {
            rank=3,
            user_id="user-0004",
        }
    },
    keyId="key-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('season_rating')

api_result_handler = client.vote_multiple_async({
    namespaceName="namespace-0001",
    signedBallots={
        {
            body="aaa",
            signature="bbb",
        },
        {
            body="aaa",
            signature="bbb",
        },
        {
            body="aaa",
            signature="bbb",
        },
        {
            body="aaa",
            signature="bbb",
        }
    },
    gameResults={
        {
            rank=1,
            user_id="user-0001",
        },
        {
            rank=2,
            user_id="user-0002",
        },
        {
            rank=2,
            user_id="user-0003",
        },
        {
            rank=3,
            user_id="user-0004",
        }
    },
    keyId="key-0001",
})

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

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CommitVoteRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->commitVote(
        (new CommitVoteRequest())
            ->withNamespaceName("namespace-0001")
            ->withSeasonName("rating-0001")
            ->withSessionName("gathering-0001")
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.CommitVoteRequest;
import io.gs2.seasonRating.result.CommitVoteResult;

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

try {
    CommitVoteResult result = client.commitVote(
        new CommitVoteRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("rating-0001")
            .withSessionName("gathering-0001")
    );
} 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.CommitVoteResult> asyncResult = null;
yield return client.CommitVote(
    new Gs2.Gs2SeasonRating.Request.CommitVoteRequest()
        .WithNamespaceName("namespace-0001")
        .WithSeasonName("rating-0001")
        .WithSessionName("gathering-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.commitVote(
        new Gs2SeasonRating.CommitVoteRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("rating-0001")
            .withSessionName("gathering-0001")
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.commit_vote(
        season_rating.CommitVoteRequest()
            .with_namespace_name('namespace-0001')
            .with_season_name('rating-0001')
            .with_session_name('gathering-0001')
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.commit_vote({
    namespaceName="namespace-0001",
    seasonName="rating-0001",
    sessionName="gathering-0001",
})

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

result = api_result.result

client = gs2('season_rating')

api_result_handler = client.commit_vote_async({
    namespaceName="namespace-0001",
    seasonName="rating-0001",
    sessionName="gathering-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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DescribeSeasonModelsRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->describeSeasonModels(
        (new DescribeSeasonModelsRequest())
            ->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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.DescribeSeasonModelsRequest;
import io.gs2.seasonRating.result.DescribeSeasonModelsResult;

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

try {
    DescribeSeasonModelsResult result = client.describeSeasonModels(
        new DescribeSeasonModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<SeasonModel> 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.DescribeSeasonModelsResult> asyncResult = null;
yield return client.DescribeSeasonModels(
    new Gs2.Gs2SeasonRating.Request.DescribeSeasonModelsRequest()
        .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 Gs2SeasonRating from '@/gs2/seasonRating';

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

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

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.describe_season_models(
        season_rating.DescribeSeasonModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.describe_season_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('season_rating')

api_result_handler = client.describe_season_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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetSeasonModelRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->getSeasonModel(
        (new GetSeasonModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withSeasonName("mode1")
    );
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetSeasonModelRequest;
import io.gs2.seasonRating.result.GetSeasonModelResult;

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

try {
    GetSeasonModelResult result = client.getSeasonModel(
        new GetSeasonModelRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
    );
    SeasonModel 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.GetSeasonModelResult> asyncResult = null;
yield return client.GetSeasonModel(
    new Gs2.Gs2SeasonRating.Request.GetSeasonModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithSeasonName("mode1"),
    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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.getSeasonModel(
        new Gs2SeasonRating.GetSeasonModelRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.get_season_model(
        season_rating.GetSeasonModelRequest()
            .with_namespace_name('namespace-0001')
            .with_season_name('mode1')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.get_season_model({
    namespaceName="namespace-0001",
    seasonName="mode1",
})

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('season_rating')

api_result_handler = client.get_season_model_async({
    namespaceName="namespace-0001",
    seasonName="mode1",
})

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\ExportMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.ExportMasterRequest;
import io.gs2.seasonRating.result.ExportMasterResult;

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

try {
    ExportMasterResult result = client.exportMaster(
        new ExportMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentSeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

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

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

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

from gs2 import core
from gs2 import season_rating

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

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

client = gs2('season_rating')

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('season_rating')

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetCurrentSeasonModelMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->getCurrentSeasonModelMaster(
        (new GetCurrentSeasonModelMasterRequest())
            ->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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetCurrentSeasonModelMasterRequest;
import io.gs2.seasonRating.result.GetCurrentSeasonModelMasterResult;

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

try {
    GetCurrentSeasonModelMasterResult result = client.getCurrentSeasonModelMaster(
        new GetCurrentSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentSeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.GetCurrentSeasonModelMasterResult> asyncResult = null;
yield return client.GetCurrentSeasonModelMaster(
    new Gs2.Gs2SeasonRating.Request.GetCurrentSeasonModelMasterRequest()
        .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 Gs2SeasonRating from '@/gs2/seasonRating';

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

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

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.get_current_season_model_master(
        season_rating.GetCurrentSeasonModelMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.get_current_season_model_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('season_rating')

api_result_handler = client.get_current_season_model_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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\PreUpdateCurrentSeasonModelMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentSeasonModelMaster(
        (new PreUpdateCurrentSeasonModelMasterRequest())
            ->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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.PreUpdateCurrentSeasonModelMasterRequest;
import io.gs2.seasonRating.result.PreUpdateCurrentSeasonModelMasterResult;

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

try {
    PreUpdateCurrentSeasonModelMasterResult result = client.preUpdateCurrentSeasonModelMaster(
        new PreUpdateCurrentSeasonModelMasterRequest()
            .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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.PreUpdateCurrentSeasonModelMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentSeasonModelMaster(
    new Gs2.Gs2SeasonRating.Request.PreUpdateCurrentSeasonModelMasterRequest()
        .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 Gs2SeasonRating from '@/gs2/seasonRating';

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

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

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.pre_update_current_season_model_master(
        season_rating.PreUpdateCurrentSeasonModelMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.pre_update_current_season_model_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('season_rating')

api_result_handler = client.pre_update_current_season_model_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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\UpdateCurrentSeasonModelMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->updateCurrentSeasonModelMaster(
        (new UpdateCurrentSeasonModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings("{\"version\": \"2024-02-23\", \"seasonModels\": [{\"name\": \"season1\", \"tiers\": [{\"raiseRankBonus\": 0, \"entryFee\": 0, \"minimumChangePoint\": -10, \"maximumChangePoint\": 20}, {\"raiseRankBonus\": 30, \"entryFee\": 10, \"minimumChangePoint\": -10, \"maximumChangePoint\": 30}, {\"raiseRankBonus\": 60, \"entryFee\": 20, \"minimumChangePoint\": -20, \"maximumChangePoint\": 50}, {\"raiseRankBonus\": 60, \"entryFee\": 30, \"minimumChangePoint\": -30, \"maximumChangePoint\": 60}], \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level\", \"challengePeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\"}]}")
            ->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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.UpdateCurrentSeasonModelMasterRequest;
import io.gs2.seasonRating.result.UpdateCurrentSeasonModelMasterResult;

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

try {
    UpdateCurrentSeasonModelMasterResult result = client.updateCurrentSeasonModelMaster(
        new UpdateCurrentSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2024-02-23\", \"seasonModels\": [{\"name\": \"season1\", \"tiers\": [{\"raiseRankBonus\": 0, \"entryFee\": 0, \"minimumChangePoint\": -10, \"maximumChangePoint\": 20}, {\"raiseRankBonus\": 30, \"entryFee\": 10, \"minimumChangePoint\": -10, \"maximumChangePoint\": 30}, {\"raiseRankBonus\": 60, \"entryFee\": 20, \"minimumChangePoint\": -20, \"maximumChangePoint\": 50}, {\"raiseRankBonus\": 60, \"entryFee\": 30, \"minimumChangePoint\": -30, \"maximumChangePoint\": 60}], \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level\", \"challengePeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\"}]}")
            .withUploadToken(null)
    );
    CurrentSeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.UpdateCurrentSeasonModelMasterResult> asyncResult = null;
yield return client.UpdateCurrentSeasonModelMaster(
    new Gs2.Gs2SeasonRating.Request.UpdateCurrentSeasonModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\"version\": \"2024-02-23\", \"seasonModels\": [{\"name\": \"season1\", \"tiers\": [{\"raiseRankBonus\": 0, \"entryFee\": 0, \"minimumChangePoint\": -10, \"maximumChangePoint\": 20}, {\"raiseRankBonus\": 30, \"entryFee\": 10, \"minimumChangePoint\": -10, \"maximumChangePoint\": 30}, {\"raiseRankBonus\": 60, \"entryFee\": 20, \"minimumChangePoint\": -20, \"maximumChangePoint\": 50}, {\"raiseRankBonus\": 60, \"entryFee\": 30, \"minimumChangePoint\": -30, \"maximumChangePoint\": 60}], \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level\", \"challengePeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\"}]}")
        .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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.updateCurrentSeasonModelMaster(
        new Gs2SeasonRating.UpdateCurrentSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2024-02-23\", \"seasonModels\": [{\"name\": \"season1\", \"tiers\": [{\"raiseRankBonus\": 0, \"entryFee\": 0, \"minimumChangePoint\": -10, \"maximumChangePoint\": 20}, {\"raiseRankBonus\": 30, \"entryFee\": 10, \"minimumChangePoint\": -10, \"maximumChangePoint\": 30}, {\"raiseRankBonus\": 60, \"entryFee\": 20, \"minimumChangePoint\": -20, \"maximumChangePoint\": 50}, {\"raiseRankBonus\": 60, \"entryFee\": 30, \"minimumChangePoint\": -30, \"maximumChangePoint\": 60}], \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level\", \"challengePeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\"}]}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.update_current_season_model_master(
        season_rating.UpdateCurrentSeasonModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{"version": "2024-02-23", "seasonModels": [{"name": "season1", "tiers": [{"raiseRankBonus": 0, "entryFee": 0, "minimumChangePoint": -10, "maximumChangePoint": 20}, {"raiseRankBonus": 30, "entryFee": 10, "minimumChangePoint": -10, "maximumChangePoint": 30}, {"raiseRankBonus": 60, "entryFee": 20, "minimumChangePoint": -20, "maximumChangePoint": 50}, {"raiseRankBonus": 60, "entryFee": 30, "minimumChangePoint": -30, "maximumChangePoint": 60}], "experienceModelId": "grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level", "challengePeriodEventId": "grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001"}]}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.update_current_season_model_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2024-02-23\", \"seasonModels\": [{\"name\": \"season1\", \"tiers\": [{\"raiseRankBonus\": 0, \"entryFee\": 0, \"minimumChangePoint\": -10, \"maximumChangePoint\": 20}, {\"raiseRankBonus\": 30, \"entryFee\": 10, \"minimumChangePoint\": -10, \"maximumChangePoint\": 30}, {\"raiseRankBonus\": 60, \"entryFee\": 20, \"minimumChangePoint\": -20, \"maximumChangePoint\": 50}, {\"raiseRankBonus\": 60, \"entryFee\": 30, \"minimumChangePoint\": -30, \"maximumChangePoint\": 60}], \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level\", \"challengePeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\"}]}",
    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('season_rating')

api_result_handler = client.update_current_season_model_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2024-02-23\", \"seasonModels\": [{\"name\": \"season1\", \"tiers\": [{\"raiseRankBonus\": 0, \"entryFee\": 0, \"minimumChangePoint\": -10, \"maximumChangePoint\": 20}, {\"raiseRankBonus\": 30, \"entryFee\": 10, \"minimumChangePoint\": -10, \"maximumChangePoint\": 30}, {\"raiseRankBonus\": 60, \"entryFee\": 20, \"minimumChangePoint\": -20, \"maximumChangePoint\": 50}, {\"raiseRankBonus\": 60, \"entryFee\": 30, \"minimumChangePoint\": -30, \"maximumChangePoint\": 60}], \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level\", \"challengePeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\"}]}",
    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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\UpdateCurrentSeasonModelMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->updateCurrentSeasonModelMasterFromGitHub(
        (new UpdateCurrentSeasonModelMasterFromGitHubRequest())
            ->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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.UpdateCurrentSeasonModelMasterFromGitHubRequest;
import io.gs2.seasonRating.result.UpdateCurrentSeasonModelMasterFromGitHubResult;

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

try {
    UpdateCurrentSeasonModelMasterFromGitHubResult result = client.updateCurrentSeasonModelMasterFromGitHub(
        new UpdateCurrentSeasonModelMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    CurrentSeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.UpdateCurrentSeasonModelMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentSeasonModelMasterFromGitHub(
    new Gs2.Gs2SeasonRating.Request.UpdateCurrentSeasonModelMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2SeasonRating.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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.updateCurrentSeasonModelMasterFromGitHub(
        new Gs2SeasonRating.UpdateCurrentSeasonModelMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2SeasonRating.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 season_rating

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

try:
    result = client.update_current_season_model_master_from_git_hub(
        season_rating.UpdateCurrentSeasonModelMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(season_rating.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('season_rating')

api_result = client.update_current_season_model_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('season_rating')

api_result_handler = client.update_current_season_model_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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DescribeSeasonModelMastersRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->describeSeasonModelMasters(
        (new DescribeSeasonModelMastersRequest())
            ->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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.DescribeSeasonModelMastersRequest;
import io.gs2.seasonRating.result.DescribeSeasonModelMastersResult;

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

try {
    DescribeSeasonModelMastersResult result = client.describeSeasonModelMasters(
        new DescribeSeasonModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    List<SeasonModelMaster> 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.DescribeSeasonModelMastersResult> asyncResult = null;
yield return client.DescribeSeasonModelMasters(
    new Gs2.Gs2SeasonRating.Request.DescribeSeasonModelMastersRequest()
        .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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.describeSeasonModelMasters(
        new Gs2SeasonRating.DescribeSeasonModelMastersRequest()
            .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 season_rating

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

try:
    result = client.describe_season_model_masters(
        season_rating.DescribeSeasonModelMastersRequest()
            .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('season_rating')

api_result = client.describe_season_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('season_rating')

api_result_handler = client.describe_season_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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\CreateSeasonModelMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->createSeasonModelMaster(
        (new CreateSeasonModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("mode1")
            ->withDescription(null)
            ->withMetadata(null)
            ->withTiers([
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(0)
                    ->withEntryFee(0)
                    ->withMinimumChangePoint(-10)
                    ->withMaximumChangePoint(20),
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(30)
                    ->withEntryFee(10)
                    ->withMinimumChangePoint(-10)
                    ->withMaximumChangePoint(30),
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(60)
                    ->withEntryFee(20)
                    ->withMinimumChangePoint(-20)
                    ->withMaximumChangePoint(50),
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(60)
                    ->withEntryFee(30)
                    ->withMinimumChangePoint(-30)
                    ->withMaximumChangePoint(60),
            ])
            ->withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level")
            ->withChallengePeriodEventId(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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.CreateSeasonModelMasterRequest;
import io.gs2.seasonRating.result.CreateSeasonModelMasterResult;

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

try {
    CreateSeasonModelMasterResult result = client.createSeasonModelMaster(
        new CreateSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("mode1")
            .withDescription(null)
            .withMetadata(null)
            .withTiers(Arrays.asList(
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(0)
                    .withEntryFee(0)
                    .withMinimumChangePoint(-10)
                    .withMaximumChangePoint(20),
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(30)
                    .withEntryFee(10)
                    .withMinimumChangePoint(-10)
                    .withMaximumChangePoint(30),
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(60)
                    .withEntryFee(20)
                    .withMinimumChangePoint(-20)
                    .withMaximumChangePoint(50),
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(60)
                    .withEntryFee(30)
                    .withMinimumChangePoint(-30)
                    .withMaximumChangePoint(60)
            ))
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level")
            .withChallengePeriodEventId(null)
    );
    SeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.CreateSeasonModelMasterResult> asyncResult = null;
yield return client.CreateSeasonModelMaster(
    new Gs2.Gs2SeasonRating.Request.CreateSeasonModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("mode1")
        .WithDescription(null)
        .WithMetadata(null)
        .WithTiers(new Gs2.Gs2SeasonRating.Model.TierModel[] {
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(0)
                .WithEntryFee(0)
                .WithMinimumChangePoint(-10)
                .WithMaximumChangePoint(20),
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(30)
                .WithEntryFee(10)
                .WithMinimumChangePoint(-10)
                .WithMaximumChangePoint(30),
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(60)
                .WithEntryFee(20)
                .WithMinimumChangePoint(-20)
                .WithMaximumChangePoint(50),
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(60)
                .WithEntryFee(30)
                .WithMinimumChangePoint(-30)
                .WithMaximumChangePoint(60),
        })
        .WithExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level")
        .WithChallengePeriodEventId(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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.createSeasonModelMaster(
        new Gs2SeasonRating.CreateSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("mode1")
            .withDescription(null)
            .withMetadata(null)
            .withTiers([
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(0)
                    .withEntryFee(0)
                    .withMinimumChangePoint(-10)
                    .withMaximumChangePoint(20),
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(30)
                    .withEntryFee(10)
                    .withMinimumChangePoint(-10)
                    .withMaximumChangePoint(30),
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(60)
                    .withEntryFee(20)
                    .withMinimumChangePoint(-20)
                    .withMaximumChangePoint(50),
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(60)
                    .withEntryFee(30)
                    .withMinimumChangePoint(-30)
                    .withMaximumChangePoint(60),
            ])
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level")
            .withChallengePeriodEventId(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.create_season_model_master(
        season_rating.CreateSeasonModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('mode1')
            .with_description(None)
            .with_metadata(None)
            .with_tiers([
                season_rating.TierModel()
                    .with_raise_rank_bonus(0)
                    .with_entry_fee(0)
                    .with_minimum_change_point(-10)
                    .with_maximum_change_point(20),
                season_rating.TierModel()
                    .with_raise_rank_bonus(30)
                    .with_entry_fee(10)
                    .with_minimum_change_point(-10)
                    .with_maximum_change_point(30),
                season_rating.TierModel()
                    .with_raise_rank_bonus(60)
                    .with_entry_fee(20)
                    .with_minimum_change_point(-20)
                    .with_maximum_change_point(50),
                season_rating.TierModel()
                    .with_raise_rank_bonus(60)
                    .with_entry_fee(30)
                    .with_minimum_change_point(-30)
                    .with_maximum_change_point(60),
            ])
            .with_experience_model_id('grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level')
            .with_challenge_period_event_id(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.create_season_model_master({
    namespaceName="namespace-0001",
    name="mode1",
    description=nil,
    metadata=nil,
    tiers={
        {
            raiseRankBonus=0,
            entryFee=0,
            minimumChangePoint=-10,
            maximumChangePoint=20,
        },
        {
            raiseRankBonus=30,
            entryFee=10,
            minimumChangePoint=-10,
            maximumChangePoint=30,
        },
        {
            raiseRankBonus=60,
            entryFee=20,
            minimumChangePoint=-20,
            maximumChangePoint=50,
        },
        {
            raiseRankBonus=60,
            entryFee=30,
            minimumChangePoint=-30,
            maximumChangePoint=60,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level",
    challengePeriodEventId=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('season_rating')

api_result_handler = client.create_season_model_master_async({
    namespaceName="namespace-0001",
    name="mode1",
    description=nil,
    metadata=nil,
    tiers={
        {
            raiseRankBonus=0,
            entryFee=0,
            minimumChangePoint=-10,
            maximumChangePoint=20,
        },
        {
            raiseRankBonus=30,
            entryFee=10,
            minimumChangePoint=-10,
            maximumChangePoint=30,
        },
        {
            raiseRankBonus=60,
            entryFee=20,
            minimumChangePoint=-20,
            maximumChangePoint=50,
        },
        {
            raiseRankBonus=60,
            entryFee=30,
            minimumChangePoint=-30,
            maximumChangePoint=60,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level",
    challengePeriodEventId=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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\GetSeasonModelMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->getSeasonModelMaster(
        (new GetSeasonModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withSeasonName("mode1")
    );
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.GetSeasonModelMasterRequest;
import io.gs2.seasonRating.result.GetSeasonModelMasterResult;

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

try {
    GetSeasonModelMasterResult result = client.getSeasonModelMaster(
        new GetSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
    );
    SeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.GetSeasonModelMasterResult> asyncResult = null;
yield return client.GetSeasonModelMaster(
    new Gs2.Gs2SeasonRating.Request.GetSeasonModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithSeasonName("mode1"),
    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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.getSeasonModelMaster(
        new Gs2SeasonRating.GetSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.get_season_model_master(
        season_rating.GetSeasonModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_season_name('mode1')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.get_season_model_master({
    namespaceName="namespace-0001",
    seasonName="mode1",
})

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('season_rating')

api_result_handler = client.get_season_model_master_async({
    namespaceName="namespace-0001",
    seasonName="mode1",
})

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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\UpdateSeasonModelMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->updateSeasonModelMaster(
        (new UpdateSeasonModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withSeasonName("mode1")
            ->withDescription("description1")
            ->withMetadata(null)
            ->withTiers([
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(0)
                    ->withEntryFee(0)
                    ->withMinimumChangePoint(-100)
                    ->withMaximumChangePoint(200),
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(300)
                    ->withEntryFee(100)
                    ->withMinimumChangePoint(-100)
                    ->withMaximumChangePoint(300),
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(600)
                    ->withEntryFee(200)
                    ->withMinimumChangePoint(-200)
                    ->withMaximumChangePoint(500),
                (new \Gs2\SeasonRating\Model\TierModel())
                    ->withRaiseRankBonus(600)
                    ->withEntryFee(300)
                    ->withMinimumChangePoint(-300)
                    ->withMaximumChangePoint(600),
            ])
            ->withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level2")
            ->withChallengePeriodEventId(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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.UpdateSeasonModelMasterRequest;
import io.gs2.seasonRating.result.UpdateSeasonModelMasterResult;

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

try {
    UpdateSeasonModelMasterResult result = client.updateSeasonModelMaster(
        new UpdateSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
            .withDescription("description1")
            .withMetadata(null)
            .withTiers(Arrays.asList(
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(0)
                    .withEntryFee(0)
                    .withMinimumChangePoint(-100)
                    .withMaximumChangePoint(200),
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(300)
                    .withEntryFee(100)
                    .withMinimumChangePoint(-100)
                    .withMaximumChangePoint(300),
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(600)
                    .withEntryFee(200)
                    .withMinimumChangePoint(-200)
                    .withMaximumChangePoint(500),
                new io.gs2.seasonRating.model.TierModel()
                    .withRaiseRankBonus(600)
                    .withEntryFee(300)
                    .withMinimumChangePoint(-300)
                    .withMaximumChangePoint(600)
            ))
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level2")
            .withChallengePeriodEventId(null)
    );
    SeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.UpdateSeasonModelMasterResult> asyncResult = null;
yield return client.UpdateSeasonModelMaster(
    new Gs2.Gs2SeasonRating.Request.UpdateSeasonModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithSeasonName("mode1")
        .WithDescription("description1")
        .WithMetadata(null)
        .WithTiers(new Gs2.Gs2SeasonRating.Model.TierModel[] {
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(0)
                .WithEntryFee(0)
                .WithMinimumChangePoint(-100)
                .WithMaximumChangePoint(200),
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(300)
                .WithEntryFee(100)
                .WithMinimumChangePoint(-100)
                .WithMaximumChangePoint(300),
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(600)
                .WithEntryFee(200)
                .WithMinimumChangePoint(-200)
                .WithMaximumChangePoint(500),
            new Gs2.Gs2SeasonRating.Model.TierModel()
                .WithRaiseRankBonus(600)
                .WithEntryFee(300)
                .WithMinimumChangePoint(-300)
                .WithMaximumChangePoint(600),
        })
        .WithExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level2")
        .WithChallengePeriodEventId(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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.updateSeasonModelMaster(
        new Gs2SeasonRating.UpdateSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
            .withDescription("description1")
            .withMetadata(null)
            .withTiers([
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(0)
                    .withEntryFee(0)
                    .withMinimumChangePoint(-100)
                    .withMaximumChangePoint(200),
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(300)
                    .withEntryFee(100)
                    .withMinimumChangePoint(-100)
                    .withMaximumChangePoint(300),
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(600)
                    .withEntryFee(200)
                    .withMinimumChangePoint(-200)
                    .withMaximumChangePoint(500),
                new Gs2SeasonRating.model.TierModel()
                    .withRaiseRankBonus(600)
                    .withEntryFee(300)
                    .withMinimumChangePoint(-300)
                    .withMaximumChangePoint(600),
            ])
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level2")
            .withChallengePeriodEventId(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.update_season_model_master(
        season_rating.UpdateSeasonModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_season_name('mode1')
            .with_description('description1')
            .with_metadata(None)
            .with_tiers([
                season_rating.TierModel()
                    .with_raise_rank_bonus(0)
                    .with_entry_fee(0)
                    .with_minimum_change_point(-100)
                    .with_maximum_change_point(200),
                season_rating.TierModel()
                    .with_raise_rank_bonus(300)
                    .with_entry_fee(100)
                    .with_minimum_change_point(-100)
                    .with_maximum_change_point(300),
                season_rating.TierModel()
                    .with_raise_rank_bonus(600)
                    .with_entry_fee(200)
                    .with_minimum_change_point(-200)
                    .with_maximum_change_point(500),
                season_rating.TierModel()
                    .with_raise_rank_bonus(600)
                    .with_entry_fee(300)
                    .with_minimum_change_point(-300)
                    .with_maximum_change_point(600),
            ])
            .with_experience_model_id('grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level2')
            .with_challenge_period_event_id(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.update_season_model_master({
    namespaceName="namespace-0001",
    seasonName="mode1",
    description="description1",
    metadata=nil,
    tiers={
        {
            raiseRankBonus=0,
            entryFee=0,
            minimumChangePoint=-100,
            maximumChangePoint=200,
        },
        {
            raiseRankBonus=300,
            entryFee=100,
            minimumChangePoint=-100,
            maximumChangePoint=300,
        },
        {
            raiseRankBonus=600,
            entryFee=200,
            minimumChangePoint=-200,
            maximumChangePoint=500,
        },
        {
            raiseRankBonus=600,
            entryFee=300,
            minimumChangePoint=-300,
            maximumChangePoint=600,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level2",
    challengePeriodEventId=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('season_rating')

api_result_handler = client.update_season_model_master_async({
    namespaceName="namespace-0001",
    seasonName="mode1",
    description="description1",
    metadata=nil,
    tiers={
        {
            raiseRankBonus=0,
            entryFee=0,
            minimumChangePoint=-100,
            maximumChangePoint=200,
        },
        {
            raiseRankBonus=300,
            entryFee=100,
            minimumChangePoint=-100,
            maximumChangePoint=300,
        },
        {
            raiseRankBonus=600,
            entryFee=200,
            minimumChangePoint=-200,
            maximumChangePoint=500,
        },
        {
            raiseRankBonus=600,
            entryFee=300,
            minimumChangePoint=-300,
            maximumChangePoint=600,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:level2",
    challengePeriodEventId=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\SeasonRating\Gs2SeasonRatingRestClient;
use Gs2\SeasonRating\Request\DeleteSeasonModelMasterRequest;

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

$session->open();

$client = new Gs2SeasonRatingRestClient(
    $session
);

try {
    $result = $client->deleteSeasonModelMaster(
        (new DeleteSeasonModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withSeasonName("mode1")
    );
    $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.seasonRating.rest.Gs2SeasonRatingRestClient;
import io.gs2.seasonRating.request.DeleteSeasonModelMasterRequest;
import io.gs2.seasonRating.result.DeleteSeasonModelMasterResult;

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

try {
    DeleteSeasonModelMasterResult result = client.deleteSeasonModelMaster(
        new DeleteSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
    );
    SeasonModelMaster 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 Gs2SeasonRatingRestClient(session);

AsyncResult<Gs2.Gs2SeasonRating.Result.DeleteSeasonModelMasterResult> asyncResult = null;
yield return client.DeleteSeasonModelMaster(
    new Gs2.Gs2SeasonRating.Request.DeleteSeasonModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithSeasonName("mode1"),
    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 Gs2SeasonRating from '@/gs2/seasonRating';

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

try {
    const result = await client.deleteSeasonModelMaster(
        new Gs2SeasonRating.DeleteSeasonModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withSeasonName("mode1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import season_rating

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

try:
    result = client.delete_season_model_master(
        season_rating.DeleteSeasonModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_season_name('mode1')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('season_rating')

api_result = client.delete_season_model_master({
    namespaceName="namespace-0001",
    seasonName="mode1",
})

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('season_rating')

api_result_handler = client.delete_season_model_master_async({
    namespaceName="namespace-0001",
    seasonName="mode1",
})

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;