GS2-MegaField SDK API Reference

Specification of models and API references for GS2-MegaField SDK for various programming languages

Models

Namespace

A Namespace allows multiple independent instances of the same service within a single project by separating data spaces and usage contexts. Each GS2 service is managed on a per-namespace basis. Even when using the same service, if the namespace differs, the data is treated as a completely independent data space.

Therefore, you must create a namespace before you can start using each service.

Details

	Type	Required	Default	Value Limits	Description
namespaceId	string	*		~ 1024 chars	Namespace GRN * Set automatically by the server
name	string	✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
description	string			~ 1024 chars	Description
logSetting	LogSetting				Log Output Setting
createdAt	long	*	Current time		Creation Timestamp Unix time, milliseconds * Set automatically by the server
updatedAt	long	*	Current time		Last Updated Timestamp Unix time, milliseconds * Set automatically by the server
revision	long		0	0 ~ 9223372036854775805	Revision

LogSetting

Log Output Setting

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

Details

	Type	Condition	Required	Default	Value Limits	Description
loggingNamespaceId	string		✓		~ 1024 chars	GS2-Log namespace GRN to output logs Must be specified in GRN format starting with “grn:gs2:”.

GitHubCheckoutSetting

Setting for checking out master data from GitHub

Details

Type

Condition

Required

Default

Value Limits

Description

apiKeyId

string

✓

~ 1024 chars

GitHub API Key GRN

repositoryName

string

✓

~ 1024 chars

Repository Name

sourcePath

string

✓

~ 1024 chars

Master data (JSON) file path

referenceType

string (enum)
enum {
  “commit_hash”,
  “branch”,
  “tag”
}

✓

Source of code

Definition	Description
“commit_hash”	Commit hash
“branch”	Branch
“tag”	Tag

commitHash

string

{referenceType} == “commit_hash”

✓*

~ 1024 chars

Commit hash

* Required if referenceType is “commit_hash”

branchName

string

{referenceType} == “branch”

✓*

~ 1024 chars

Branch Name

* Required if referenceType is “branch”

tagName

string

{referenceType} == “tag”

✓*

~ 1024 chars

Tag Name

* Required if referenceType is “tag”

Layer

Details

	Type	Required	Default	Value Limits	Description
layerId	string	*		~ 1024 chars	Layer GRN * Set automatically by the server
areaModelName	string	✓		~ 128 chars	Area name
layerModelName	string	✓		~ 128 chars	Layer name
numberOfMinEntries	int		5	1 ~ 1000	Attempts to join with other nodes when the number of entities in a node falls below a specified value
numberOfMaxEntries	int		20	1 ~ 1000	Attempts to split a node if the number of entities in the node exceeds the specified value
createdAt	long	*	Current time		Creation Timestamp Unix time, milliseconds * Set automatically by the server

Spatial

Details

	Type	Required	Default	Value Limits	Description
spatialId	string	*		~ 1024 chars	Serial Key GRN * Set automatically by the server
userId	string	✓		~ 128 chars	User ID
areaModelName	string	✓		~ 128 chars	Area name
layerModelName	string	✓		~ 128 chars	Layer name
position	Position	✓			Position
vector	Vector	✓			Vector
r	float		1	0 ~ 10000	Radius
lastSyncAt	long				Last Synchronization Date and Time for Layer
createdAt	long	*	Current time		Creation Timestamp Unix time, milliseconds * Set automatically by the server

AreaModel

Area divides space, and different areas can be treated as different spaces even if they have the same coordinates.

Details

	Type	Required	Default	Value Limits	Description
areaModelId	string	*		~ 1024 chars	Area Model GRN * Set automatically by the server
name	string	✓		~ 128 chars	Area Model name
metadata	string			~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.
layerModels	List<LayerModel>		[]	0 ~ 1000 items	List of layer models

LayerModel

Layers allow for multiple logical hierarchies within a single space. For example, it solves the problem of an Enemy being invisible in a space with a large number of characters. Characters are placed on Layer 1. If Enemies are placed on Layer 2, there is no need to worry about them becoming invisible, since each layer can specify the quantity to be acquired within a specified distance.

Details

	Type	Required	Value Limits	Description
layerModelId	string	*	~ 1024 chars	Layer Model GRN * Set automatically by the server
name	string	✓	~ 128 chars	Layer Model name
metadata	string		~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.

Position

Details

	Type	Required	Value Limits	Description
x	float	✓	-1048574 ~ 1048574	X position
y	float	✓	-1048574 ~ 1048574	Y position
z	float	✓	-1048574 ~ 1048574	Z position

MyPosition

My Location

Details

	Type	Required	Default	Value Limits	Description
position	Position	✓			Position
vector	Vector	✓			Vector
r	float		1	0 ~ 10000	Radius

Scope

Surroundings to be acquired

Details

	Type	Required	Value Limits	Description
layerName	string	✓	~ 128 chars	Layer Model name
r	float	✓	1 ~ 16777214	Radius
limit	int	✓	1 ~ 100	Maximum number of result

Vector

Position

Details

	Type	Required	Value Limits	Description
x	float	✓	-1048574 ~ 1048574	X position
y	float	✓	-1048574 ~ 1048574	Y position
z	float	✓	-1048574 ~ 1048574	Z position

CurrentFieldMaster

Currently active Field Model master data

This master data defines the Field Models currently active within the namespace. GS2 uses JSON format files for managing master data. By uploading these files, the master data are updated on the server.

To create JSON files, GS2 provides a master data editor within the management console. Additionally, you can create tools better suited for game operations and export JSON files in the appropriate format.

Note

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

Details

	Type	Condition	Required	Default	Value Limits	Description
namespaceId	string		*		~ 1024 chars	Namespace GRN * Set automatically by the server
settings	string		✓		~ 5242880 bytes (5MB)	Master Data

AreaModelMaster

Area divides space, and different areas can be treated as different spaces even if they have the same coordinates.

Details

	Type	Required	Default	Value Limits	Description
areaModelMasterId	string	*		~ 1024 chars	Area Model Master GRN * Set automatically by the server
name	string	✓		~ 128 chars	Area Model name
description	string			~ 1024 chars	Description
metadata	string			~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.
createdAt	long	*	Current time		Creation Timestamp Unix time, milliseconds * Set automatically by the server
updatedAt	long	*	Current time		Last Updated Timestamp Unix time, milliseconds * Set automatically by the server
revision	long		0	0 ~ 9223372036854775805	Revision

LayerModelMaster

Details

	Type	Required	Default	Value Limits	Description
layerModelMasterId	string	*		~ 1024 chars	Layer Model Master GRN * Set automatically by the server
name	string	✓		~ 128 chars	Layer Model name
description	string			~ 1024 chars	Description
metadata	string			~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.
createdAt	long	*	Current time		Creation Timestamp Unix time, milliseconds * Set automatically by the server
updatedAt	long	*	Current time		Last Updated Timestamp Unix time, milliseconds * Set automatically by the server
revision	long		0	0 ~ 9223372036854775805	Revision

Methods

describeNamespaces

Get a list of Namespaces

Retrieves a list of namespaces that have been created on a per-service basis within the project. You can use the optional page token to start acquiring data from a specific location in the list. You can also limit the number of namespaces to be acquired.

Details

Request

	Type	Default	Value Limits	Description
namePrefix	string		~ 64 chars	Filter by Namespace name prefix
pageToken	string		~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	30	1 ~ 1000	Number of data items to retrieve

Result

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

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &mega_field.DescribeNamespacesRequest {
        NamePrefix: nil,
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeNamespacesRequest;

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

$session->open();

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

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

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

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

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

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

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

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

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;

createNamespace

Create a new Namespace

You must specify detailed information including the name, description, and various settings of the namespace.

Details

Request

	Type	Required	Value Limits	Description
name	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
description	string		~ 1024 chars	Description
logSetting	LogSetting			Log Output Setting

Result

	Type	Description
item	Namespace	Namespace created

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &mega_field.CreateNamespaceRequest {
        Name: pointy.String("namespace-0001"),
        Description: nil,
        LogSetting: &megaField.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

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

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

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

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

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

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

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

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

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

api_result_handler = client.create_namespace_async({
    name="namespace-0001",
    description=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;

getNamespaceStatus

Get Namespace status

Get the current status of the specified namespace. This includes whether the Namespace is active, pending, or in some other state.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
status	string

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &mega_field.GetNamespaceStatusRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
status := result.Status

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetNamespaceStatusRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import mega_field

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

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

client = gs2('mega_field')

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

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;

getNamespace

Get a Namespace

Get detailed information about the specified namespace. This includes the name, description, and other settings of the namespace.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	Namespace	Namespace

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &mega_field.GetNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetNamespaceRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import mega_field

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

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

client = gs2('mega_field')

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

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;

updateNamespace

Update Namespace

Update the settings of the specified Namespace. You can change the description and other settings of the Namespace.

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
description	string		~ 1024 chars	Description
logSetting	LogSetting			Log Output Setting

Result

	Type	Description
item	Namespace	Namespace updated

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &mega_field.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Description: pointy.String("description1"),
        LogSetting: &megaField.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

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

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

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

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

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

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

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

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

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

api_result_handler = client.update_namespace_async({
    namespaceName="namespace-0001",
    description="description1",
    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;

deleteNamespace

Delete Namespace

Delete the specified Namespace. This operation is irreversible and all data associated with the deleted Namespace will be lost.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	Namespace	The deleted Namespace

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &mega_field.DeleteNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DeleteNamespaceRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import mega_field

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

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

client = gs2('mega_field')

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

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;

getServiceVersion

Get the microservice version

Details

Request

Request parameters: None

Result

	Type	Description
item	string	Version

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetServiceVersion(
    &mega_field.GetServiceVersionRequest {
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetServiceVersionRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import mega_field

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

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

client = gs2('mega_field')

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

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;

putPosition

Put position

Details

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
accessToken	string	✓		~ 128 chars	Access token
areaModelName	string	✓		~ 128 chars	Area name
layerModelName	string	✓		~ 128 chars	Layer name
position	Position	✓			Position
vector	Vector	✓			Vector
r	float		1	0 ~ 10000	Radius

Result

	Type	Description
item	Spatial	Spatial

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.PutPosition(
    &mega_field.PutPositionRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        Position: &megaField.Position{
            X: pointy.Float32(0),
            Y: pointy.Float32(1),
            Z: pointy.Float32(2),
        },
        Vector: &megaField.Vector{
            X: pointy.Float32(10),
            Y: pointy.Float32(11),
            Z: pointy.Float32(12),
        },
        R: pointy.Float32(5),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\PutPositionRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->putPosition(
        (new PutPositionRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withPosition((new Position())
                ->withX(0)
                ->withY(1)
                ->withZ(2)
            )
            ->withVector((new Vector())
                ->withX(10)
                ->withY(11)
                ->withZ(12)
            )
            ->withR(5)
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.PutPositionRequest;
import io.gs2.megaField.result.PutPositionResult;

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

try {
    PutPositionResult result = client.putPosition(
        new PutPositionRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(new Position()
                .withX(0f)
                .withY(1f)
                .withZ(2f)
            )
            .withVector(new Vector()
                .withX(10f)
                .withY(11f)
                .withZ(12f)
            )
            .withR(5f)
    );
    Spatial 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.PutPositionResult> asyncResult = null;
yield return client.PutPosition(
    new Gs2.Gs2MegaField.Request.PutPositionRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithPosition(new Gs2.Gs2MegaField.Model.Position()
            .WithX(0f)
            .WithY(1f)
            .WithZ(2f)
        )
        .WithVector(new Gs2.Gs2MegaField.Model.Vector()
            .WithX(10f)
            .WithY(11f)
            .WithZ(12f)
        )
        .WithR(5f),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.putPosition(
        new Gs2MegaField.PutPositionRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(new Gs2MegaField.model.Position()
                .withX(0)
                .withY(1)
                .withZ(2)
            )
            .withVector(new Gs2MegaField.model.Vector()
                .withX(10)
                .withY(11)
                .withZ(12)
            )
            .withR(5)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.put_position(
        mega_field.PutPositionRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_position(mega_field.Position()
                .with_x(0)
                .with_y(1)
                .with_z(2)
            )
            .with_vector(mega_field.Vector()
                .with_x(10)
                .with_y(11)
                .with_z(12)
            )
            .with_r(5)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.put_position({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position={
        x=0,
        y=1,
        z=2,
    },
    vector={
        x=10,
        y=11,
        z=12,
    },
    r=5,
})

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

api_result_handler = client.put_position_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position={
        x=0,
        y=1,
        z=2,
    },
    vector={
        x=10,
        y=11,
        z=12,
    },
    r=5,
})

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;

putPositionByUserId

Put position by specifying a user ID

Details

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
userId	string	✓		~ 128 chars	User ID
areaModelName	string	✓		~ 128 chars	Area name
layerModelName	string	✓		~ 128 chars	Layer name
position	Position	✓			Position
vector	Vector	✓			Vector
r	float		1	0 ~ 10000	Radius
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	Spatial	Spatial

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.PutPositionByUserId(
    &mega_field.PutPositionByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        Position: &megaField.Position{
            X: pointy.Float32(0),
            Y: pointy.Float32(1),
            Z: pointy.Float32(2),
        },
        Vector: &megaField.Vector{
            X: pointy.Float32(10),
            Y: pointy.Float32(11),
            Z: pointy.Float32(12),
        },
        R: pointy.Float32(5),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\PutPositionByUserIdRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->putPositionByUserId(
        (new PutPositionByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withPosition((new Position())
                ->withX(0)
                ->withY(1)
                ->withZ(2)
            )
            ->withVector((new Vector())
                ->withX(10)
                ->withY(11)
                ->withZ(12)
            )
            ->withR(5)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.PutPositionByUserIdRequest;
import io.gs2.megaField.result.PutPositionByUserIdResult;

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

try {
    PutPositionByUserIdResult result = client.putPositionByUserId(
        new PutPositionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(new Position()
                .withX(0f)
                .withY(1f)
                .withZ(2f)
            )
            .withVector(new Vector()
                .withX(10f)
                .withY(11f)
                .withZ(12f)
            )
            .withR(5f)
            .withTimeOffsetToken(null)
    );
    Spatial 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.PutPositionByUserIdResult> asyncResult = null;
yield return client.PutPositionByUserId(
    new Gs2.Gs2MegaField.Request.PutPositionByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithPosition(new Gs2.Gs2MegaField.Model.Position()
            .WithX(0f)
            .WithY(1f)
            .WithZ(2f)
        )
        .WithVector(new Gs2.Gs2MegaField.Model.Vector()
            .WithX(10f)
            .WithY(11f)
            .WithZ(12f)
        )
        .WithR(5f)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.putPositionByUserId(
        new Gs2MegaField.PutPositionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(new Gs2MegaField.model.Position()
                .withX(0)
                .withY(1)
                .withZ(2)
            )
            .withVector(new Gs2MegaField.model.Vector()
                .withX(10)
                .withY(11)
                .withZ(12)
            )
            .withR(5)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.put_position_by_user_id(
        mega_field.PutPositionByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_position(mega_field.Position()
                .with_x(0)
                .with_y(1)
                .with_z(2)
            )
            .with_vector(mega_field.Vector()
                .with_x(10)
                .with_y(11)
                .with_z(12)
            )
            .with_r(5)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.put_position_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position={
        x=0,
        y=1,
        z=2,
    },
    vector={
        x=10,
        y=11,
        z=12,
    },
    r=5,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('mega_field')

api_result_handler = client.put_position_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position={
        x=0,
        y=1,
        z=2,
    },
    vector={
        x=10,
        y=11,
        z=12,
    },
    r=5,
    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;

fetchPosition

Fetch position

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
accessToken	string	✓	~ 128 chars	Access token
areaModelName	string	✓	~ 128 chars	Area name
layerModelName	string	✓	~ 128 chars	Layer name
userIds	List<string>	✓	1 ~ 100 items	List of User IDs

Result

	Type	Description
items	List<Spatial>	List of Spatial

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.FetchPosition(
    &mega_field.FetchPositionRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        UserIds: []*string{
            pointy.String("user-0001"),
            pointy.String("user-0002"),
            pointy.String("user-0003"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\FetchPositionRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->fetchPosition(
        (new FetchPositionRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withUserIds([
                "user-0001",
                "user-0002",
                "user-0003",
            ])
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.FetchPositionRequest;
import io.gs2.megaField.result.FetchPositionResult;

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

try {
    FetchPositionResult result = client.fetchPosition(
        new FetchPositionRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withUserIds(Arrays.asList(
                "user-0001",
                "user-0002",
                "user-0003"
            ))
    );
    List<Spatial> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.FetchPositionResult> asyncResult = null;
yield return client.FetchPosition(
    new Gs2.Gs2MegaField.Request.FetchPositionRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithUserIds(new string[] {
            "user-0001",
            "user-0002",
            "user-0003",
        }),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.fetchPosition(
        new Gs2MegaField.FetchPositionRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withUserIds([
                "user-0001",
                "user-0002",
                "user-0003",
            ])
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.fetch_position(
        mega_field.FetchPositionRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_user_ids([
                'user-0001',
                'user-0002',
                'user-0003',
            ])
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.fetch_position({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    userIds={
        "user-0001",
        "user-0002",
        "user-0003"
    },
})

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

api_result_handler = client.fetch_position_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    userIds={
        "user-0001",
        "user-0002",
        "user-0003"
    },
})

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

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

result = api_result.result
items = result.items;

fetchPositionFromSystem

Fetch position

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area name
layerModelName	string	✓	~ 128 chars	Layer name
userIds	List<string>	✓	1 ~ 100 items	List of User IDs

Result

	Type	Description
items	List<Spatial>	List of Spatial

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.FetchPositionFromSystem(
    &mega_field.FetchPositionFromSystemRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        UserIds: []*string{
            pointy.String("user-0001"),
            pointy.String("user-0002"),
            pointy.String("user-0003"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\FetchPositionFromSystemRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->fetchPositionFromSystem(
        (new FetchPositionFromSystemRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withUserIds([
                "user-0001",
                "user-0002",
                "user-0003",
            ])
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.FetchPositionFromSystemRequest;
import io.gs2.megaField.result.FetchPositionFromSystemResult;

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

try {
    FetchPositionFromSystemResult result = client.fetchPositionFromSystem(
        new FetchPositionFromSystemRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withUserIds(Arrays.asList(
                "user-0001",
                "user-0002",
                "user-0003"
            ))
    );
    List<Spatial> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.FetchPositionFromSystemResult> asyncResult = null;
yield return client.FetchPositionFromSystem(
    new Gs2.Gs2MegaField.Request.FetchPositionFromSystemRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithUserIds(new string[] {
            "user-0001",
            "user-0002",
            "user-0003",
        }),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.fetchPositionFromSystem(
        new Gs2MegaField.FetchPositionFromSystemRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withUserIds([
                "user-0001",
                "user-0002",
                "user-0003",
            ])
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.fetch_position_from_system(
        mega_field.FetchPositionFromSystemRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_user_ids([
                'user-0001',
                'user-0002',
                'user-0003',
            ])
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.fetch_position_from_system({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    userIds={
        "user-0001",
        "user-0002",
        "user-0003"
    },
})

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

api_result_handler = client.fetch_position_from_system_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    userIds={
        "user-0001",
        "user-0002",
        "user-0003"
    },
})

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

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

result = api_result.result
items = result.items;

nearUserIds

Fetch list of nearby user IDs

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
accessToken	string	✓	~ 128 chars	Access token
areaModelName	string	✓	~ 128 chars	Area name
layerModelName	string	✓	~ 128 chars	Layer name
point	Position	✓		Point
r	float	✓	1 ~ 16777214	Radius
limit	int	✓	1 ~ 100	Maximum number of result

Result

	Type	Description
items	List<string>	List of nearby user IDs

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.NearUserIds(
    &mega_field.NearUserIdsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        Point: nil,
        R: pointy.Float32(5),
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\NearUserIdsRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->nearUserIds(
        (new NearUserIdsRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withPoint(null)
            ->withR(5)
            ->withLimit(null)
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.NearUserIdsRequest;
import io.gs2.megaField.result.NearUserIdsResult;

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

try {
    NearUserIdsResult result = client.nearUserIds(
        new NearUserIdsRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPoint(null)
            .withR(5f)
            .withLimit(null)
    );
    List<String> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.NearUserIdsResult> asyncResult = null;
yield return client.NearUserIds(
    new Gs2.Gs2MegaField.Request.NearUserIdsRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithPoint(null)
        .WithR(5f)
        .WithLimit(null),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.nearUserIds(
        new Gs2MegaField.NearUserIdsRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPoint(null)
            .withR(5)
            .withLimit(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.near_user_ids(
        mega_field.NearUserIdsRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_point(None)
            .with_r(5)
            .with_limit(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.near_user_ids({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    point=nil,
    r=5,
    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;

client = gs2('mega_field')

api_result_handler = client.near_user_ids_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    point=nil,
    r=5,
    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;

nearUserIdsFromSystem

Fetch list of nearby user IDs

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area name
layerModelName	string	✓	~ 128 chars	Layer name
point	Position	✓		Point
r	float	✓	1 ~ 16777214	Radius
limit	int	✓	1 ~ 100	Maximum number of result

Result

	Type	Description
items	List<string>	List of nearby user IDs

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.NearUserIdsFromSystem(
    &mega_field.NearUserIdsFromSystemRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        Point: nil,
        R: pointy.Float32(5),
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\NearUserIdsFromSystemRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->nearUserIdsFromSystem(
        (new NearUserIdsFromSystemRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withPoint(null)
            ->withR(5)
            ->withLimit(null)
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.NearUserIdsFromSystemRequest;
import io.gs2.megaField.result.NearUserIdsFromSystemResult;

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

try {
    NearUserIdsFromSystemResult result = client.nearUserIdsFromSystem(
        new NearUserIdsFromSystemRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPoint(null)
            .withR(5f)
            .withLimit(null)
    );
    List<String> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.NearUserIdsFromSystemResult> asyncResult = null;
yield return client.NearUserIdsFromSystem(
    new Gs2.Gs2MegaField.Request.NearUserIdsFromSystemRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithPoint(null)
        .WithR(5f)
        .WithLimit(null),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.nearUserIdsFromSystem(
        new Gs2MegaField.NearUserIdsFromSystemRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPoint(null)
            .withR(5)
            .withLimit(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.near_user_ids_from_system(
        mega_field.NearUserIdsFromSystemRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_point(None)
            .with_r(5)
            .with_limit(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.near_user_ids_from_system({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    point=nil,
    r=5,
    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;

client = gs2('mega_field')

api_result_handler = client.near_user_ids_from_system_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    point=nil,
    r=5,
    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;

action

Put position

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
accessToken	string	✓	~ 128 chars	Access token
areaModelName	string	✓	~ 128 chars	Area name
layerModelName	string	✓	~ 128 chars	Layer name
position	MyPosition	✓		My Location
scopes	List<Scope>		0 ~ 10 items	List of Scope of acquisition by other players

Result

	Type	Description
items	List<Spatial>	List of Spatial

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.Action(
    &mega_field.ActionRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        Position: nil,
        Scopes: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\ActionRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->action(
        (new ActionRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withPosition(null)
            ->withScopes(null)
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.ActionRequest;
import io.gs2.megaField.result.ActionResult;

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

try {
    ActionResult result = client.action(
        new ActionRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(null)
            .withScopes(null)
    );
    List<Spatial> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.ActionResult> asyncResult = null;
yield return client.Action(
    new Gs2.Gs2MegaField.Request.ActionRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithPosition(null)
        .WithScopes(null),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.action(
        new Gs2MegaField.ActionRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(null)
            .withScopes(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.action(
        mega_field.ActionRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_position(None)
            .with_scopes(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.action({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position=nil,
    scopes=nil,
})

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

api_result_handler = client.action_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position=nil,
    scopes=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;

actionByUserId

Put position by specifying a user ID

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
userId	string	✓	~ 128 chars	User ID
areaModelName	string	✓	~ 128 chars	Area name
layerModelName	string	✓	~ 128 chars	Layer name
position	MyPosition	✓		My Location
scopes	List<Scope>		0 ~ 10 items	List of Scope of acquisition by other players
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
items	List<Spatial>	List of Spatial

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.ActionByUserId(
    &mega_field.ActionByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        Position: nil,
        Scopes: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\ActionByUserIdRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->actionByUserId(
        (new ActionByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withPosition(null)
            ->withScopes(null)
            ->withTimeOffsetToken(null)
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.ActionByUserIdRequest;
import io.gs2.megaField.result.ActionByUserIdResult;

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

try {
    ActionByUserIdResult result = client.actionByUserId(
        new ActionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(null)
            .withScopes(null)
            .withTimeOffsetToken(null)
    );
    List<Spatial> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.ActionByUserIdResult> asyncResult = null;
yield return client.ActionByUserId(
    new Gs2.Gs2MegaField.Request.ActionByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithPosition(null)
        .WithScopes(null)
        .WithTimeOffsetToken(null),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.actionByUserId(
        new Gs2MegaField.ActionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withPosition(null)
            .withScopes(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.action_by_user_id(
        mega_field.ActionByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_position(None)
            .with_scopes(None)
            .with_time_offset_token(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.action_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position=nil,
    scopes=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
items = result.items;

client = gs2('mega_field')

api_result_handler = client.action_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    position=nil,
    scopes=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
items = result.items;

describeAreaModels

Get a list of Area Models

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
items	List<AreaModel>	List of Area Models

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DescribeAreaModels(
    &mega_field.DescribeAreaModelsRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeAreaModelsRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->describeAreaModels(
        (new DescribeAreaModelsRequest())
            ->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeAreaModelsRequest;
import io.gs2.megaField.result.DescribeAreaModelsResult;

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

try {
    DescribeAreaModelsResult result = client.describeAreaModels(
        new DescribeAreaModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<AreaModel> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.DescribeAreaModelsResult> asyncResult = null;
yield return client.DescribeAreaModels(
    new Gs2.Gs2MegaField.Request.DescribeAreaModelsRequest()
        .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 Gs2MegaField from '@/gs2/megaField';

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

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

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.describe_area_models(
        mega_field.DescribeAreaModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.describe_area_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('mega_field')

api_result_handler = client.describe_area_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;

getAreaModel

Get Area Model

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string		✓		~ 128 chars	Area Model name

Result

	Type	Description
item	AreaModel	Area Model

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetAreaModel(
    &mega_field.GetAreaModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetAreaModelRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->getAreaModel(
        (new GetAreaModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetAreaModelRequest;
import io.gs2.megaField.result.GetAreaModelResult;

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

try {
    GetAreaModelResult result = client.getAreaModel(
        new GetAreaModelRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    AreaModel 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.GetAreaModelResult> asyncResult = null;
yield return client.GetAreaModel(
    new Gs2.Gs2MegaField.Request.GetAreaModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.getAreaModel(
        new Gs2MegaField.GetAreaModelRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.get_area_model(
        mega_field.GetAreaModelRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.get_area_model({
    namespaceName="namespace-0001",
    areaModelName="area-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('mega_field')

api_result_handler = client.get_area_model_async({
    namespaceName="namespace-0001",
    areaModelName="area-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;

describeLayerModels

Get a list of Layer Models

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string		✓		~ 128 chars	Area Model name

Result

	Type	Description
items	List<LayerModel>	List of Layer Models

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DescribeLayerModels(
    &mega_field.DescribeLayerModelsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeLayerModelsRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->describeLayerModels(
        (new DescribeLayerModelsRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeLayerModelsRequest;
import io.gs2.megaField.result.DescribeLayerModelsResult;

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

try {
    DescribeLayerModelsResult result = client.describeLayerModels(
        new DescribeLayerModelsRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    List<LayerModel> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.DescribeLayerModelsResult> asyncResult = null;
yield return client.DescribeLayerModels(
    new Gs2.Gs2MegaField.Request.DescribeLayerModelsRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.describeLayerModels(
        new Gs2MegaField.DescribeLayerModelsRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.describe_layer_models(
        mega_field.DescribeLayerModelsRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.describe_layer_models({
    namespaceName="namespace-0001",
    areaModelName="area-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('mega_field')

api_result_handler = client.describe_layer_models_async({
    namespaceName="namespace-0001",
    areaModelName="area-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;

getLayerModel

Get Layer Model

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area Model name
layerModelName	string	✓	~ 128 chars	Layer Model name

Result

	Type	Description
item	LayerModel

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetLayerModel(
    &mega_field.GetLayerModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetLayerModelRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->getLayerModel(
        (new GetLayerModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetLayerModelRequest;
import io.gs2.megaField.result.GetLayerModelResult;

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

try {
    GetLayerModelResult result = client.getLayerModel(
        new GetLayerModelRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
    );
    LayerModel 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.GetLayerModelResult> asyncResult = null;
yield return client.GetLayerModel(
    new Gs2.Gs2MegaField.Request.GetLayerModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.getLayerModel(
        new Gs2MegaField.GetLayerModelRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.get_layer_model(
        mega_field.GetLayerModelRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.get_layer_model({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-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('mega_field')

api_result_handler = client.get_layer_model_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-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;

exportMaster

Export Model Master in a master data format that can be activated

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	CurrentFieldMaster	master data that can be activated

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.ExportMaster(
    &mega_field.ExportMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\ExportMasterRequest;

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

$session->open();

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

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

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

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

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

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

from gs2 import core
from gs2 import mega_field

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

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

client = gs2('mega_field')

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

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;

getCurrentFieldMaster

Get currently active Field Model master data

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	CurrentFieldMaster	Currently active Field Model master data

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetCurrentFieldMaster(
    &mega_field.GetCurrentFieldMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetCurrentFieldMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->getCurrentFieldMaster(
        (new GetCurrentFieldMasterRequest())
            ->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetCurrentFieldMasterRequest;
import io.gs2.megaField.result.GetCurrentFieldMasterResult;

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

try {
    GetCurrentFieldMasterResult result = client.getCurrentFieldMaster(
        new GetCurrentFieldMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentFieldMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.GetCurrentFieldMasterResult> asyncResult = null;
yield return client.GetCurrentFieldMaster(
    new Gs2.Gs2MegaField.Request.GetCurrentFieldMasterRequest()
        .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 Gs2MegaField from '@/gs2/megaField';

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

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

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.get_current_field_master(
        mega_field.GetCurrentFieldMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.get_current_field_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('mega_field')

api_result_handler = client.get_current_field_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;

preUpdateCurrentFieldMaster

Update currently active Field Model master data (3-phase version)

When uploading master data larger than 1MB, the update is performed in 3 phases.

Execute this API to obtain a token and URL for uploading.
Upload the master data to the obtained URL.
Execute UpdateCurrentModelMaster by passing the token obtained from the the upload to reflect the master data.

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

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

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.PreUpdateCurrentFieldMaster(
    &mega_field.PreUpdateCurrentFieldMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\PreUpdateCurrentFieldMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentFieldMaster(
        (new PreUpdateCurrentFieldMasterRequest())
            ->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.PreUpdateCurrentFieldMasterRequest;
import io.gs2.megaField.result.PreUpdateCurrentFieldMasterResult;

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

try {
    PreUpdateCurrentFieldMasterResult result = client.preUpdateCurrentFieldMaster(
        new PreUpdateCurrentFieldMasterRequest()
            .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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.PreUpdateCurrentFieldMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentFieldMaster(
    new Gs2.Gs2MegaField.Request.PreUpdateCurrentFieldMasterRequest()
        .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 Gs2MegaField from '@/gs2/megaField';

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

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

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.pre_update_current_field_master(
        mega_field.PreUpdateCurrentFieldMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.pre_update_current_field_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('mega_field')

api_result_handler = client.pre_update_current_field_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;

updateCurrentFieldMaster

Update currently active Field Model master data

Details

Request

Type

Condition

Required

Default

Value Limits

Description

namespaceName

string

✓

~ 128 chars

Namespace name

Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

mode

string (enum)
enum {
“direct”,
“preUpload”
}

“direct”

Update mode

Definition	Description
“direct”	Directly update master data
“preUpload”	Upload master data and then update

settings

string

{mode} == “direct”

✓*

~ 5242880 chars

Master Data

* Required if mode is “direct”

uploadToken

string

{mode} == “preUpload”

✓*

~ 1024 chars

Token obtained by pre-upload

Used to apply the uploaded master data.

* Required if mode is “preUpload”

Result

	Type	Description
item	CurrentFieldMaster	Updated master data of the currently active Field Models

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentFieldMaster(
    &mega_field.UpdateCurrentFieldMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Mode: pointy.String("direct"),
        Settings: pointy.String("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}"),
        UploadToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateCurrentFieldMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->updateCurrentFieldMaster(
        (new UpdateCurrentFieldMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateCurrentFieldMasterRequest;
import io.gs2.megaField.result.UpdateCurrentFieldMasterResult;

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

try {
    UpdateCurrentFieldMasterResult result = client.updateCurrentFieldMaster(
        new UpdateCurrentFieldMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}")
            .withUploadToken(null)
    );
    CurrentFieldMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.UpdateCurrentFieldMasterResult> asyncResult = null;
yield return client.UpdateCurrentFieldMaster(
    new Gs2.Gs2MegaField.Request.UpdateCurrentFieldMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.updateCurrentFieldMaster(
        new Gs2MegaField.UpdateCurrentFieldMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_0001\"}]}]}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.update_current_field_master(
        mega_field.UpdateCurrentFieldMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{"version": "2022-08-28", "areaModels": [{"name": "area-0001", "metadata": "AREA_0001", "layerModels": [{"name": "layer-0001", "metadata": "LAYER_0001"}]}]}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.update_current_field_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_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('mega_field')

api_result_handler = client.update_current_field_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2022-08-28\", \"areaModels\": [{\"name\": \"area-0001\", \"metadata\": \"AREA_0001\", \"layerModels\": [{\"name\": \"layer-0001\", \"metadata\": \"LAYER_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;

updateCurrentFieldMasterFromGitHub

Update currently active Field Model master data from GitHub

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
checkoutSetting	GitHubCheckoutSetting		✓			Setting for checking out master data from GitHub

Result

	Type	Description
item	CurrentFieldMaster	Updated master data of the currently active Field Models

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentFieldMasterFromGitHub(
    &mega_field.UpdateCurrentFieldMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace-0001"),
        CheckoutSetting: &megaField.GitHubCheckoutSetting{
            ApiKeyId: pointy.String("apiKeyId-0001"),
            RepositoryName: pointy.String("gs2io/master-data"),
            SourcePath: pointy.String("path/to/file.json"),
            ReferenceType: pointy.String("branch"),
            BranchName: pointy.String("develop"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateCurrentFieldMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->updateCurrentFieldMasterFromGitHub(
        (new UpdateCurrentFieldMasterFromGitHubRequest())
            ->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateCurrentFieldMasterFromGitHubRequest;
import io.gs2.megaField.result.UpdateCurrentFieldMasterFromGitHubResult;

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

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

AsyncResult<Gs2.Gs2MegaField.Result.UpdateCurrentFieldMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentFieldMasterFromGitHub(
    new Gs2.Gs2MegaField.Request.UpdateCurrentFieldMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2MegaField.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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.updateCurrentFieldMasterFromGitHub(
        new Gs2MegaField.UpdateCurrentFieldMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2MegaField.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 mega_field

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

try:
    result = client.update_current_field_master_from_git_hub(
        mega_field.UpdateCurrentFieldMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(mega_field.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('mega_field')

api_result = client.update_current_field_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('mega_field')

api_result_handler = client.update_current_field_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;

describeAreaModelMasters

Get a list of Area Model Masters

Details

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int		30	1 ~ 1000	Number of data acquired

Result

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

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DescribeAreaModelMasters(
    &mega_field.DescribeAreaModelMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeAreaModelMastersRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->describeAreaModelMasters(
        (new DescribeAreaModelMastersRequest())
            ->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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeAreaModelMastersRequest;
import io.gs2.megaField.result.DescribeAreaModelMastersResult;

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

try {
    DescribeAreaModelMastersResult result = client.describeAreaModelMasters(
        new DescribeAreaModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<AreaModelMaster> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.DescribeAreaModelMastersResult> asyncResult = null;
yield return client.DescribeAreaModelMasters(
    new Gs2.Gs2MegaField.Request.DescribeAreaModelMastersRequest()
        .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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.describeAreaModelMasters(
        new Gs2MegaField.DescribeAreaModelMastersRequest()
            .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 mega_field

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

try:
    result = client.describe_area_model_masters(
        mega_field.DescribeAreaModelMastersRequest()
            .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('mega_field')

api_result = client.describe_area_model_masters({
    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('mega_field')

api_result_handler = client.describe_area_model_masters_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;

createAreaModelMaster

Create a new Area Model Master

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
name	string	✓	~ 128 chars	Area Model name
description	string		~ 1024 chars	Description
metadata	string		~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.

Result

	Type	Description
item	AreaModelMaster	Area Model Master created

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.CreateAreaModelMaster(
    &mega_field.CreateAreaModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("area-0001"),
        Description: nil,
        Metadata: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\CreateAreaModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->createAreaModelMaster(
        (new CreateAreaModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("area-0001")
            ->withDescription(null)
            ->withMetadata(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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.CreateAreaModelMasterRequest;
import io.gs2.megaField.result.CreateAreaModelMasterResult;

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

try {
    CreateAreaModelMasterResult result = client.createAreaModelMaster(
        new CreateAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("area-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    AreaModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.CreateAreaModelMasterResult> asyncResult = null;
yield return client.CreateAreaModelMaster(
    new Gs2.Gs2MegaField.Request.CreateAreaModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("area-0001")
        .WithDescription(null)
        .WithMetadata(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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.createAreaModelMaster(
        new Gs2MegaField.CreateAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("area-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.create_area_model_master(
        mega_field.CreateAreaModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('area-0001')
            .with_description(None)
            .with_metadata(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.create_area_model_master({
    namespaceName="namespace-0001",
    name="area-0001",
    description=nil,
    metadata=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('mega_field')

api_result_handler = client.create_area_model_master_async({
    namespaceName="namespace-0001",
    name="area-0001",
    description=nil,
    metadata=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;

getAreaModelMaster

Get Area Model Master

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string		✓		~ 128 chars	Area Model name

Result

	Type	Description
item	AreaModelMaster	Area Model Master

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetAreaModelMaster(
    &mega_field.GetAreaModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetAreaModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->getAreaModelMaster(
        (new GetAreaModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetAreaModelMasterRequest;
import io.gs2.megaField.result.GetAreaModelMasterResult;

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

try {
    GetAreaModelMasterResult result = client.getAreaModelMaster(
        new GetAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    AreaModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.GetAreaModelMasterResult> asyncResult = null;
yield return client.GetAreaModelMaster(
    new Gs2.Gs2MegaField.Request.GetAreaModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.getAreaModelMaster(
        new Gs2MegaField.GetAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.get_area_model_master(
        mega_field.GetAreaModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.get_area_model_master({
    namespaceName="namespace-0001",
    areaModelName="area-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('mega_field')

api_result_handler = client.get_area_model_master_async({
    namespaceName="namespace-0001",
    areaModelName="area-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;

updateAreaModelMaster

Update Area Model Master

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area Model name
description	string		~ 1024 chars	Description
metadata	string		~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.

Result

	Type	Description
item	AreaModelMaster	Area Model Master updated

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.UpdateAreaModelMaster(
    &mega_field.UpdateAreaModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("AREA_MASTER"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateAreaModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->updateAreaModelMaster(
        (new UpdateAreaModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withDescription("description1")
            ->withMetadata("AREA_MASTER")
    );
    $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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateAreaModelMasterRequest;
import io.gs2.megaField.result.UpdateAreaModelMasterResult;

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

try {
    UpdateAreaModelMasterResult result = client.updateAreaModelMaster(
        new UpdateAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withDescription("description1")
            .withMetadata("AREA_MASTER")
    );
    AreaModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.UpdateAreaModelMasterResult> asyncResult = null;
yield return client.UpdateAreaModelMaster(
    new Gs2.Gs2MegaField.Request.UpdateAreaModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithDescription("description1")
        .WithMetadata("AREA_MASTER"),
    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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.updateAreaModelMaster(
        new Gs2MegaField.UpdateAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withDescription("description1")
            .withMetadata("AREA_MASTER")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.update_area_model_master(
        mega_field.UpdateAreaModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_description('description1')
            .with_metadata('AREA_MASTER')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.update_area_model_master({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    description="description1",
    metadata="AREA_MASTER",
})

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

api_result_handler = client.update_area_model_master_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    description="description1",
    metadata="AREA_MASTER",
})

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;

deleteAreaModelMaster

Delete Area Model Master

Details

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string		✓		~ 128 chars	Area Model name

Result

	Type	Description
item	AreaModelMaster	Area Model Master deleted

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DeleteAreaModelMaster(
    &mega_field.DeleteAreaModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DeleteAreaModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->deleteAreaModelMaster(
        (new DeleteAreaModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DeleteAreaModelMasterRequest;
import io.gs2.megaField.result.DeleteAreaModelMasterResult;

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

try {
    DeleteAreaModelMasterResult result = client.deleteAreaModelMaster(
        new DeleteAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    AreaModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.DeleteAreaModelMasterResult> asyncResult = null;
yield return client.DeleteAreaModelMaster(
    new Gs2.Gs2MegaField.Request.DeleteAreaModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.deleteAreaModelMaster(
        new Gs2MegaField.DeleteAreaModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.delete_area_model_master(
        mega_field.DeleteAreaModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.delete_area_model_master({
    namespaceName="namespace-0001",
    areaModelName="area-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('mega_field')

api_result_handler = client.delete_area_model_master_async({
    namespaceName="namespace-0001",
    areaModelName="area-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;

describeLayerModelMasters

Get a list of Layer Model Masters

Details

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓		~ 128 chars	Area Model name
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int		30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<LayerModelMaster>	List of Layer Model Master
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DescribeLayerModelMasters(
    &mega_field.DescribeLayerModelMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DescribeLayerModelMastersRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->describeLayerModelMasters(
        (new DescribeLayerModelMastersRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DescribeLayerModelMastersRequest;
import io.gs2.megaField.result.DescribeLayerModelMastersResult;

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

try {
    DescribeLayerModelMastersResult result = client.describeLayerModelMasters(
        new DescribeLayerModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<LayerModelMaster> 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.DescribeLayerModelMastersResult> asyncResult = null;
yield return client.DescribeLayerModelMasters(
    new Gs2.Gs2MegaField.Request.DescribeLayerModelMastersRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.describeLayerModelMasters(
        new Gs2MegaField.DescribeLayerModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-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 mega_field

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

try:
    result = client.describe_layer_model_masters(
        mega_field.DescribeLayerModelMastersRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-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('mega_field')

api_result = client.describe_layer_model_masters({
    namespaceName="namespace-0001",
    areaModelName="area-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('mega_field')

api_result_handler = client.describe_layer_model_masters_async({
    namespaceName="namespace-0001",
    areaModelName="area-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;

createLayerModelMaster

Create a new Layer Model Master

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area Model name
name	string	✓	~ 128 chars	Layer Model name
description	string		~ 1024 chars	Description
metadata	string		~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.

Result

	Type	Description
item	LayerModelMaster	Item Model Master created

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.CreateLayerModelMaster(
    &mega_field.CreateLayerModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        Name: pointy.String("layer-0001"),
        Description: nil,
        Metadata: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\CreateLayerModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->createLayerModelMaster(
        (new CreateLayerModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withName("layer-0001")
            ->withDescription(null)
            ->withMetadata(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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.CreateLayerModelMasterRequest;
import io.gs2.megaField.result.CreateLayerModelMasterResult;

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

try {
    CreateLayerModelMasterResult result = client.createLayerModelMaster(
        new CreateLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withName("layer-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    LayerModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.CreateLayerModelMasterResult> asyncResult = null;
yield return client.CreateLayerModelMaster(
    new Gs2.Gs2MegaField.Request.CreateLayerModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithName("layer-0001")
        .WithDescription(null)
        .WithMetadata(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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.createLayerModelMaster(
        new Gs2MegaField.CreateLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withName("layer-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.create_layer_model_master(
        mega_field.CreateLayerModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_name('layer-0001')
            .with_description(None)
            .with_metadata(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.create_layer_model_master({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    name="layer-0001",
    description=nil,
    metadata=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('mega_field')

api_result_handler = client.create_layer_model_master_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    name="layer-0001",
    description=nil,
    metadata=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;

getLayerModelMaster

Get Layer Model Master

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area Model name
layerModelName	string	✓	~ 128 chars	Layer Model name

Result

	Type	Description
item	LayerModelMaster	Layer Model Master

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.GetLayerModelMaster(
    &mega_field.GetLayerModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\GetLayerModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->getLayerModelMaster(
        (new GetLayerModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.GetLayerModelMasterRequest;
import io.gs2.megaField.result.GetLayerModelMasterResult;

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

try {
    GetLayerModelMasterResult result = client.getLayerModelMaster(
        new GetLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
    );
    LayerModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.GetLayerModelMasterResult> asyncResult = null;
yield return client.GetLayerModelMaster(
    new Gs2.Gs2MegaField.Request.GetLayerModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.getLayerModelMaster(
        new Gs2MegaField.GetLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.get_layer_model_master(
        mega_field.GetLayerModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.get_layer_model_master({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-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('mega_field')

api_result_handler = client.get_layer_model_master_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-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;

updateLayerModelMaster

Update Layer Model Master

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area Model name
layerModelName	string	✓	~ 128 chars	Layer Model name
description	string		~ 1024 chars	Description
metadata	string		~ 2048 chars	Metadata Arbitrary values can be set in the metadata. Since they do not affect GS2’s behavior, they can be used to store information used in the game.

Result

	Type	Description
item	LayerModelMaster	Layer Model Master updated

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.UpdateLayerModelMaster(
    &mega_field.UpdateLayerModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("LAYER_0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\UpdateLayerModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->updateLayerModelMaster(
        (new UpdateLayerModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-0001")
            ->withDescription("description1")
            ->withMetadata("LAYER_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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.UpdateLayerModelMasterRequest;
import io.gs2.megaField.result.UpdateLayerModelMasterResult;

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

try {
    UpdateLayerModelMasterResult result = client.updateLayerModelMaster(
        new UpdateLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withDescription("description1")
            .withMetadata("LAYER_0001")
    );
    LayerModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.UpdateLayerModelMasterResult> asyncResult = null;
yield return client.UpdateLayerModelMaster(
    new Gs2.Gs2MegaField.Request.UpdateLayerModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-0001")
        .WithDescription("description1")
        .WithMetadata("LAYER_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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.updateLayerModelMaster(
        new Gs2MegaField.UpdateLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
            .withDescription("description1")
            .withMetadata("LAYER_0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.update_layer_model_master(
        mega_field.UpdateLayerModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
            .with_description('description1')
            .with_metadata('LAYER_0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.update_layer_model_master({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    description="description1",
    metadata="LAYER_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('mega_field')

api_result_handler = client.update_layer_model_master_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-0001",
    description="description1",
    metadata="LAYER_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;

deleteLayerModelMaster

Delete Layer Model Master

Details

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
areaModelName	string	✓	~ 128 chars	Area Model name
layerModelName	string	✓	~ 128 chars	Layer Model name

Result

	Type	Description
item	LayerModelMaster	Layer Model Master deleted

Implementation Example

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

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

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

client := mega_field.Gs2MegaFieldRestClient{
    Session: &session,
}
result, err := client.DeleteLayerModelMaster(
    &mega_field.DeleteLayerModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AreaModelName: pointy.String("area-0001"),
        LayerModelName: pointy.String("layer-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\MegaField\Gs2MegaFieldRestClient;
use Gs2\MegaField\Request\DeleteLayerModelMasterRequest;

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

$session->open();

$client = new Gs2MegaFieldRestClient(
    $session
);

try {
    $result = $client->deleteLayerModelMaster(
        (new DeleteLayerModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withAreaModelName("area-0001")
            ->withLayerModelName("layer-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.megaField.rest.Gs2MegaFieldRestClient;
import io.gs2.megaField.request.DeleteLayerModelMasterRequest;
import io.gs2.megaField.result.DeleteLayerModelMasterResult;

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

try {
    DeleteLayerModelMasterResult result = client.deleteLayerModelMaster(
        new DeleteLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
    );
    LayerModelMaster 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 Gs2MegaFieldRestClient(session);

AsyncResult<Gs2.Gs2MegaField.Result.DeleteLayerModelMasterResult> asyncResult = null;
yield return client.DeleteLayerModelMaster(
    new Gs2.Gs2MegaField.Request.DeleteLayerModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithAreaModelName("area-0001")
        .WithLayerModelName("layer-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 Gs2MegaField from '@/gs2/megaField';

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

try {
    const result = await client.deleteLayerModelMaster(
        new Gs2MegaField.DeleteLayerModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withAreaModelName("area-0001")
            .withLayerModelName("layer-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import mega_field

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

try:
    result = client.delete_layer_model_master(
        mega_field.DeleteLayerModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_area_model_name('area-0001')
            .with_layer_model_name('layer-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('mega_field')

api_result = client.delete_layer_model_master({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-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('mega_field')

api_result_handler = client.delete_layer_model_master_async({
    namespaceName="namespace-0001",
    areaModelName="area-0001",
    layerModelName="layer-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;