API Reference of GS2-Inventory SDK

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

Model

Namespace

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

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

	Type	Require	Default	Limitation	Description
namespaceId	string	✓		~ 1024 chars	Namespace GRN
name	string	✓		~ 128 chars	Namespace name
description	string			~ 1024 chars	Description
acquireScript	ScriptSetting				Script to be executed when an item is obtained
overflowScript	ScriptSetting				Script to be executed when the maximum acquisition limit is reached and the script cannot be obtained.
consumeScript	ScriptSetting				Script to run when consuming items
simpleItemAcquireScript	ScriptSetting				Script to be executed when an simple items is obtained
simpleItemConsumeScript	ScriptSetting				Script to run when consuming simple items
bigItemAcquireScript	ScriptSetting				Script to be executed when an big item is obtained
bigItemConsumeScript	ScriptSetting				Script to run when consuming big item
logSetting	LogSetting				Log output settings
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

InventoryModelMaster

Inventory Model Master

Inventory is like a bag that stores items owned by game players. Inventory can have a set capacity and cannot be owned beyond its capacity.

	Type	Require	Default	Limitation	Description
inventoryModelId	string	✓		~ 1024 chars	Inventory Model Master GRN
name	string	✓		~ 128 chars	Inventory Model Name
metadata	string			~ 128 chars	metadata
description	string			~ 1024 chars	Description
initialCapacity	int	✓		~ 2147483646	Initial Capacity
maxCapacity	int	✓		~ 2147483646	Maximum Capacity
protectReferencedItem	bool	✓	false		Item Sets with registered references cannot be deleted
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

InventoryModel

Inventory Model

Inventory is like a bag that stores items owned by game players. Inventory can have a set capacity and cannot be owned beyond its capacity.

	Type	Require	Default	Limitation	Description
inventoryModelId	string	✓		~ 1024 chars	Inventory model GRN
name	string	✓		~ 128 chars	Inventory Model Name
metadata	string			~ 128 chars	metadata
initialCapacity	int	✓		~ 2147483646	Initial Capacity
maxCapacity	int	✓		~ 2147483646	Maximum Capacity
protectReferencedItem	bool?		false		Item Sets with registered references cannot be deleted
itemModels	List<ItemModel>	✓		1 ~ 1000 items	List of item models that can be stored in inventory

ItemModelMaster

Item Model Master

Items can be owned more than once for one capacity of inventory, such as potion x 99. Multiple items owned in a single capacity are stacked items. The maximum number of items that can be stacked can be specified for each item.

When the maximum stackable quantity is reached, you can set for each item whether you can reserve a new inventory capacity and own it, or whether it will no longer be available.

	Type	Require	Default	Limitation	Description
itemModelId	string	✓		~ 1024 chars	Item Model Master GRN
inventoryName	string	✓		~ 128 chars	inventory model name
name	string	✓		~ 128 chars	Item Model Name
description	string			~ 1024 chars	Description
metadata	string			~ 128 chars	metadata
stackingLimit	long	✓		1 ~ 9223372036854775805	Maximum stackable quantity
allowMultipleStacks	bool	✓			Allow items to be stored in multiple slots when the maximum stackable quantity is exceeded
sortValue	int	✓		~ 2147483646	Display order
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

ItemModel

Item Model

Multiple items can be owned for one capacity of inventory, such as potions x 99. Multiple items owned in one capacity are stacked items. The maximum number of items that can be stacked can be specified for each item.

When the maximum stackable quantity is reached, you can set for each item whether you can reserve a new inventory capacity and own it, or whether it will no longer be available.

	Type	Require	Limitation	Description
itemModelId	string	✓	~ 1024 chars	Item Model GRN
name	string	✓	~ 128 chars	Item Model Name
metadata	string		~ 128 chars	metadata
stackingLimit	long	✓	1 ~ 9223372036854775805	Maximum stackable quantity
allowMultipleStacks	bool	✓		Allow items to be stored in multiple slots when the maximum stackable quantity is exceeded?
sortValue	int	✓	~ 2147483646	Display order

SimpleInventoryModelMaster

Simple Inventory Model

In a normal InventoryModel, you could limit the amount of items that could be stored in your inventory. Simple Inventory, however, has no such functionality and simply stores the number of items in the inventory.

However, the Simple Inventory provides an API that can increase or decrease the number of items in a single process.

	Type	Require	Default	Limitation	Description
inventoryModelId	string	✓		~ 1024 chars	Simple Inventory Model Master GRN
name	string	✓		~ 128 chars	Simple Inventory Model Name
metadata	string			~ 128 chars	metadata
description	string			~ 1024 chars	Description
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

SimpleInventoryModel

Simple Inventory Model

However, the Simple Inventory provides an API that can increase or decrease the number of items in a single process.

	Type	Require	Limitation	Description
inventoryModelId	string	✓	~ 1024 chars	Inventory model GRN
name	string	✓	~ 128 chars	Simple Inventory Model Name
metadata	string		~ 128 chars	metadata
simpleItemModels	List<SimpleItemModel>	✓	1 ~ 1000 items	List of simple item models that can be stored in inventory

SimpleItemModelMaster

Simple ItemModel Master

In the normal ItemModel, it is possible to set the maximum number of items that can be stacked, and if the number exceeds a certain number, it can be implemented to divide the items into multiple stacks. However, SimpleItem does not have such a function and simply stores the number of items in the possession of the item.

	Type	Require	Default	Limitation	Description
itemModelId	string	✓		~ 1024 chars	Simple Item Model Master GRN
name	string	✓		~ 128 chars	Simple Item Model Name
description	string			~ 1024 chars	Description
metadata	string			~ 128 chars	metadata
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

SimpleItemModel

Simple ItemModel

	Type	Require	Limitation	Description
itemModelId	string	✓	~ 1024 chars	Simple Item Model GRN
name	string	✓	~ 128 chars	Simple Item Model Name
metadata	string		~ 128 chars	metadata

BigInventoryModelMaster

Big Inventory model

In the normal InventoryModel and SimpleInventoryModel, the number of items that can be stored in the inventory is limited to the range of 64bit integer values. In inflationary games, you may need a wider range of values.

In the Big Inventory Model, the number of items that can be stored in the inventory can have an integer value of 1024 digits.

	Type	Require	Default	Limitation	Description
inventoryModelId	string	✓		~ 1024 chars	Big Inventory Model Master GRN
name	string	✓		~ 128 chars	Big Inventory Model Name
metadata	string			~ 128 chars	metadata
description	string			~ 1024 chars	Description
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

BigInventoryModel

Big Inventory model

In the Big Inventory Model, the number of items that can be stored in the inventory can have an integer value of 1024 digits.

	Type	Require	Limitation	Description
inventoryModelId	string	✓	~ 1024 chars	Inventory model GRN
name	string	✓	~ 128 chars	Big Inventory Model Name
metadata	string		~ 128 chars	metadata
bigItemModels	List<BigItemModel>	✓	1 ~ 1000 items	List of big item models that can be stored in inventory

BigItemModelMaster

Big ItemModel Master

In the normal ItemModel, it is possible to set the maximum number of items that can be stacked, and if the number exceeds a certain number, it can be implemented to divide the items into multiple stacks. However, BigItem does not have such a function and simply stores the number of items in the possession of the item.

	Type	Require	Default	Limitation	Description
itemModelId	string	✓		~ 1024 chars	Big Item Model Master GRN
name	string	✓		~ 128 chars	Big Item Model Name
description	string			~ 1024 chars	Description
metadata	string			~ 128 chars	metadata
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

BigItemModel

Big ItemModel

In the normal ItemModel, it is possible to set the maximum number of items that can be stacked, and if the number exceeds a certain number, it can be implemented to divide the items into multiple stacks. However, BigItem does not have such a function and simply stores the number of items in the possession of the item.

	Type	Require	Limitation	Description
itemModelId	string	✓	~ 1024 chars	Big Item Model GRN
name	string	✓	~ 128 chars	Big Item Model Name
metadata	string		~ 128 chars	metadata

CurrentItemModelMaster

Currently available master data

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

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

Note

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

	Type	Condition	Require	Default	Limitation	Description
namespaceId	string		✓		~ 1024 chars	Currently available item master GRN
settings	string		✓		~ 5242880 chars	Master data

Inventory

Inventory is like a bag that stores items owned by game players. The bag has a capacity, and the capacity can be expanded by each player.

	Type	Require	Default	Limitation	Description
inventoryId	string	✓		~ 1024 chars	Inventory GRN
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
currentInventoryCapacityUsage	int	✓	0	~ 2147483646	Capacity usage
currentInventoryMaxCapacity	int	✓		1 ~ 2147483646	Maximum capacity
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

ItemSet

Item Set

Item set represents the possessions stored in the game player’s inventory. Item set has an item model and the quantity possessed.

	Type	Require	Default	Limitation	Description
itemSetId	string	✓		~ 1024 chars	Quantity of items held per expiration date GRN
name	string	✓	UUID	~ 36 chars	Name identifying the item set
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Item Model Name
count	long	✓		1 ~ 9223372036854775805	Quantity in possession
referenceOf	List<string>			~ 24 items	List of references for this possession
sortValue	int	✓		~ 2147483646	Display order
expiresAt	long	✓	0		Effective date (Unix time unit:milliseconds)
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)

ReferenceOf

Reference of possessions

	Type	Condition	Require	Default	Limitation	Description
referenceOfId	string		✓		~ 1024 chars	Reference GRN
name	string		✓		~ 128 chars	Name identifying the item set

SimpleInventory

Simple Inventory

Simple inventory is like a bag that stores simple items owned by game players. Simple inventory does not have functions such as a cap on the number of items possessed or the capacity of the inventory, but it can increase or decrease multiple items at once.

	Type	Require	Default	Limitation	Description
inventoryId	string	✓		~ 1024 chars	Simple Inventory GRN
inventoryName	string	✓		~ 128 chars	Simple Inventory Model Name
userId	string	✓		~ 128 chars	User Id
simpleItems	List<SimpleItem>			~ 1000 items	List of simple item
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

SimpleItem

Simple Item

Simple Item represents a possession stored in the game player’s inventory. Simple Item has a model name and the quantity possessed.

	Type	Require	Default	Limitation	Description
itemId	string	✓		~ 1024 chars	Quantity of items GRN
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Simple Item Model Name
count	long	✓		~ 9223372036854775805	Quantity in possession
revision	long		0	~ 9223372036854775805	Revision

BigInventory

Big Inventory

Big inventory is like a bag that stores huge items owned by the game player. Big inventory is an inventory that can hold a quantity of items beyond the int64 range.

	Type	Require	Default	Limitation	Description
inventoryId	string	✓		~ 1024 chars	BigInventory GRN
inventoryName	string	✓		~ 128 chars	Big Inventory Model Name
userId	string	✓		~ 128 chars	User Id
bigItems	List<BigItem>			~ 1000 items	List of big item
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)

BigItem

Big item

Big item represent possessions stored in the game player’s huge inventory. Big item model name and the quantity of possessions can be held beyond the int64 range.

	Type	Require	Default	Limitation	Description
itemId	string	✓		~ 1024 chars	Quantity of items GRN
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Big Item Model Name
count	string	✓		~ 1024 chars	Quantity in possession
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

GitHubCheckoutSetting

Setup to check out master data from GitHub

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

Definition of enumeration type to be specified for referenceType

Enumerator String Definition	Description
commit_hash	Commit hash
branch	Branch
tag	Tag

ScriptSetting

Script settings

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

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

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

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

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

Definition of enumeration type to be specified for doneTriggerTargetType

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

LogSetting

Log setting

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

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

AcquireCount

Quantity of simple items obtained

	Type	Condition	Require	Default	Limitation	Description
itemName	string		✓		~ 128 chars	Simple Item Model Name
count	long		✓		1 ~ 9223372036854775805	Quantity to be obtained

ConsumeCount

Consumption quantity of simple items

	Type	Condition	Require	Default	Limitation	Description
itemName	string		✓		~ 128 chars	Simple Item Model Name
count	long		✓		1 ~ 9223372036854775805	Quantity to be consumed

HeldCount

Quantity of simple items in possession

	Type	Condition	Require	Default	Limitation	Description
itemName	string		✓		~ 128 chars	Simple Item Model Name
count	long		✓		~ 9223372036854775805	Number of items held

Methods

describeNamespaces

Get list of namespaces

Request

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

Result

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

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &inventory.DescribeNamespacesRequest {
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

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

client = gs2('inventory')

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

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

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

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

createNamespace

Create a new namespace

Request

	Type	Require	Limitation	Description
name	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
acquireScript	ScriptSetting			Script to be executed when an item is obtained
overflowScript	ScriptSetting			Script to be executed when the maximum acquisition limit is reached and the script cannot be obtained.
consumeScript	ScriptSetting			Script to run when consuming items
simpleItemAcquireScript	ScriptSetting			Script to be executed when an simple items is obtained
simpleItemConsumeScript	ScriptSetting			Script to run when consuming simple items
bigItemAcquireScript	ScriptSetting			Script to be executed when an big item is obtained
bigItemConsumeScript	ScriptSetting			Script to run when consuming big item
logSetting	LogSetting			Log output settings

Result

	Type	Description
item	Namespace	Namespace created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &inventory.CreateNamespaceRequest {
        Name: pointy.String("namespace-0001"),
        Description: nil,
        AcquireScript: nil,
        OverflowScript: nil,
        ConsumeScript: nil,
        SimpleItemAcquireScript: nil,
        SimpleItemConsumeScript: nil,
        BigItemAcquireScript: nil,
        BigItemConsumeScript: nil,
        LogSetting: &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName("namespace-0001")
            ->withDescription(null)
            ->withAcquireScript(null)
            ->withOverflowScript(null)
            ->withConsumeScript(null)
            ->withSimpleItemAcquireScript(null)
            ->withSimpleItemConsumeScript(null)
            ->withBigItemAcquireScript(null)
            ->withBigItemConsumeScript(null)
            ->withLogSetting((new \Gs2\Inventory\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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.CreateNamespaceRequest;
import io.gs2.inventory.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withAcquireScript(null)
            .withOverflowScript(null)
            .withConsumeScript(null)
            .withSimpleItemAcquireScript(null)
            .withSimpleItemConsumeScript(null)
            .withBigItemAcquireScript(null)
            .withBigItemConsumeScript(null)
            .withLogSetting(new io.gs2.inventory.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.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.CreateNamespaceRequest;
using Gs2.Gs2Inventory.Result.CreateNamespaceResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Inventory.Request.CreateNamespaceRequest()
        .WithName("namespace-0001")
        .WithDescription(null)
        .WithAcquireScript(null)
        .WithOverflowScript(null)
        .WithConsumeScript(null)
        .WithSimpleItemAcquireScript(null)
        .WithSimpleItemConsumeScript(null)
        .WithBigItemAcquireScript(null)
        .WithBigItemConsumeScript(null)
        .WithLogSetting(new Gs2.Gs2Inventory.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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.createNamespace(
        new Gs2Inventory.CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withAcquireScript(null)
            .withOverflowScript(null)
            .withConsumeScript(null)
            .withSimpleItemAcquireScript(null)
            .withSimpleItemConsumeScript(null)
            .withBigItemAcquireScript(null)
            .withBigItemConsumeScript(null)
            .withLogSetting(new Gs2Inventory.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 inventory

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

try:
    result = client.create_namespace(
        inventory.CreateNamespaceRequest()
            .with_name('namespace-0001')
            .with_description(None)
            .with_acquire_script(None)
            .with_overflow_script(None)
            .with_consume_script(None)
            .with_simple_item_acquire_script(None)
            .with_simple_item_consume_script(None)
            .with_big_item_acquire_script(None)
            .with_big_item_consume_script(None)
            .with_log_setting(
                inventory.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('inventory')

api_result = client.create_namespace({
    name="namespace-0001",
    description=nil,
    acquireScript=nil,
    overflowScript=nil,
    consumeScript=nil,
    simpleItemAcquireScript=nil,
    simpleItemConsumeScript=nil,
    bigItemAcquireScript=nil,
    bigItemConsumeScript=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['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.create_namespace_async({
    name="namespace-0001",
    description=nil,
    acquireScript=nil,
    overflowScript=nil,
    consumeScript=nil,
    simpleItemAcquireScript=nil,
    simpleItemConsumeScript=nil,
    bigItemAcquireScript=nil,
    bigItemConsumeScript=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['message'])
end

result = api_result.result
item = result.item;

getNamespaceStatus

Request

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

Result

	Type	Description
status	string

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName("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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetNamespaceStatusRequest;
import io.gs2.inventory.result.GetNamespaceStatusResult;

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

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

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

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

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

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result
status = result.status;

client = gs2('inventory')

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['message'])
end

result = api_result.result
status = result.status;

getNamespace

Get namespace

Request

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

Result

	Type	Description
item	Namespace	Namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName("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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetNamespaceRequest;
import io.gs2.inventory.result.GetNamespaceResult;

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

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

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

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

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

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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['message'])
end

result = api_result.result
item = result.item;

updateNamespace

Update namespace

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
acquireScript	ScriptSetting			Script to be executed when an item is obtained
overflowScript	ScriptSetting			Script to be executed when the maximum acquisition limit is reached and the script cannot be obtained.
consumeScript	ScriptSetting			Script to run when consuming items
simpleItemAcquireScript	ScriptSetting			Script to be executed when an simple items is obtained
simpleItemConsumeScript	ScriptSetting			Script to run when consuming simple items
bigItemAcquireScript	ScriptSetting			Script to be executed when an big item is obtained
bigItemConsumeScript	ScriptSetting			Script to run when consuming big item
logSetting	LogSetting			Log output settings

Result

	Type	Description
item	Namespace	Updated namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &inventory.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Description: pointy.String("description1"),
        AcquireScript: &inventory.ScriptSetting{
            TriggerScriptId: pointy.String("script-1001"),
            DoneTriggerScriptId: pointy.String("script-1002"),
            DoneTriggerQueueNamespaceId: pointy.String("namespace-1001"),
        },
        OverflowScript: &inventory.ScriptSetting{
            DoneTriggerScriptId: pointy.String("script-1003"),
            DoneTriggerQueueNamespaceId: pointy.String("script-1004"),
        },
        ConsumeScript: &inventory.ScriptSetting{
            TriggerScriptId: pointy.String("script-1005"),
            DoneTriggerScriptId: pointy.String("script-1006"),
            DoneTriggerQueueNamespaceId: pointy.String("namespace-1001"),
        },
        SimpleItemAcquireScript: nil,
        SimpleItemConsumeScript: nil,
        BigItemAcquireScript: nil,
        BigItemConsumeScript: nil,
        LogSetting: &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName("namespace-0001")
            ->withDescription("description1")
            ->withAcquireScript((new \Gs2\Inventory\Model\ScriptSetting())
                ->withTriggerScriptId("script-1001")
                ->withDoneTriggerScriptId("script-1002")
                ->withDoneTriggerQueueNamespaceId("namespace-1001"))
            ->withOverflowScript((new \Gs2\Inventory\Model\ScriptSetting())
                ->withDoneTriggerScriptId("script-1003")
                ->withDoneTriggerQueueNamespaceId("script-1004"))
            ->withConsumeScript((new \Gs2\Inventory\Model\ScriptSetting())
                ->withTriggerScriptId("script-1005")
                ->withDoneTriggerScriptId("script-1006")
                ->withDoneTriggerQueueNamespaceId("namespace-1001"))
            ->withSimpleItemAcquireScript(null)
            ->withSimpleItemConsumeScript(null)
            ->withBigItemAcquireScript(null)
            ->withBigItemConsumeScript(null)
            ->withLogSetting((new \Gs2\Inventory\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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateNamespaceRequest;
import io.gs2.inventory.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withAcquireScript(new io.gs2.inventory.model.ScriptSetting()
                .withTriggerScriptId("script-1001")
                .withDoneTriggerScriptId("script-1002")
                .withDoneTriggerQueueNamespaceId("namespace-1001"))
            .withOverflowScript(new io.gs2.inventory.model.ScriptSetting()
                .withDoneTriggerScriptId("script-1003")
                .withDoneTriggerQueueNamespaceId("script-1004"))
            .withConsumeScript(new io.gs2.inventory.model.ScriptSetting()
                .withTriggerScriptId("script-1005")
                .withDoneTriggerScriptId("script-1006")
                .withDoneTriggerQueueNamespaceId("namespace-1001"))
            .withSimpleItemAcquireScript(null)
            .withSimpleItemConsumeScript(null)
            .withBigItemAcquireScript(null)
            .withBigItemConsumeScript(null)
            .withLogSetting(new io.gs2.inventory.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.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateNamespaceRequest;
using Gs2.Gs2Inventory.Result.UpdateNamespaceResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Inventory.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace-0001")
        .WithDescription("description1")
        .WithAcquireScript(new Gs2.Gs2Inventory.Model.ScriptSetting()
            .WithTriggerScriptId("script-1001")
            .WithDoneTriggerScriptId("script-1002")
            .WithDoneTriggerQueueNamespaceId("namespace-1001"))
        .WithOverflowScript(new Gs2.Gs2Inventory.Model.ScriptSetting()
            .WithDoneTriggerScriptId("script-1003")
            .WithDoneTriggerQueueNamespaceId("script-1004"))
        .WithConsumeScript(new Gs2.Gs2Inventory.Model.ScriptSetting()
            .WithTriggerScriptId("script-1005")
            .WithDoneTriggerScriptId("script-1006")
            .WithDoneTriggerQueueNamespaceId("namespace-1001"))
        .WithSimpleItemAcquireScript(null)
        .WithSimpleItemConsumeScript(null)
        .WithBigItemAcquireScript(null)
        .WithBigItemConsumeScript(null)
        .WithLogSetting(new Gs2.Gs2Inventory.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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateNamespace(
        new Gs2Inventory.UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withAcquireScript(new Gs2Inventory.model.ScriptSetting()
                .withTriggerScriptId("script-1001")
                .withDoneTriggerScriptId("script-1002")
                .withDoneTriggerQueueNamespaceId("namespace-1001"))
            .withOverflowScript(new Gs2Inventory.model.ScriptSetting()
                .withDoneTriggerScriptId("script-1003")
                .withDoneTriggerQueueNamespaceId("script-1004"))
            .withConsumeScript(new Gs2Inventory.model.ScriptSetting()
                .withTriggerScriptId("script-1005")
                .withDoneTriggerScriptId("script-1006")
                .withDoneTriggerQueueNamespaceId("namespace-1001"))
            .withSimpleItemAcquireScript(null)
            .withSimpleItemConsumeScript(null)
            .withBigItemAcquireScript(null)
            .withBigItemConsumeScript(null)
            .withLogSetting(new Gs2Inventory.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 inventory

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

try:
    result = client.update_namespace(
        inventory.UpdateNamespaceRequest()
            .with_namespace_name('namespace-0001')
            .with_description('description1')
            .with_acquire_script(
                inventory.ScriptSetting()
                    .with_trigger_script_id('script-1001')
                    .with_done_trigger_script_id('script-1002')
                    .with_done_trigger_queue_namespace_id('namespace-1001'))
            .with_overflow_script(
                inventory.ScriptSetting()
                    .with_done_trigger_script_id('script-1003')
                    .with_done_trigger_queue_namespace_id('script-1004'))
            .with_consume_script(
                inventory.ScriptSetting()
                    .with_trigger_script_id('script-1005')
                    .with_done_trigger_script_id('script-1006')
                    .with_done_trigger_queue_namespace_id('namespace-1001'))
            .with_simple_item_acquire_script(None)
            .with_simple_item_consume_script(None)
            .with_big_item_acquire_script(None)
            .with_big_item_consume_script(None)
            .with_log_setting(
                inventory.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('inventory')

api_result = client.update_namespace({
    namespaceName="namespace-0001",
    description="description1",
    acquireScript={
        triggerScriptId="script-1001",
        doneTriggerScriptId="script-1002",
        doneTriggerQueueNamespaceId="namespace-1001",
    },
    overflowScript={
        doneTriggerScriptId="script-1003",
        doneTriggerQueueNamespaceId="script-1004",
    },
    consumeScript={
        triggerScriptId="script-1005",
        doneTriggerScriptId="script-1006",
        doneTriggerQueueNamespaceId="namespace-1001",
    },
    simpleItemAcquireScript=nil,
    simpleItemConsumeScript=nil,
    bigItemAcquireScript=nil,
    bigItemConsumeScript=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['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace-0001",
    description="description1",
    acquireScript={
        triggerScriptId="script-1001",
        doneTriggerScriptId="script-1002",
        doneTriggerQueueNamespaceId="namespace-1001",
    },
    overflowScript={
        doneTriggerScriptId="script-1003",
        doneTriggerQueueNamespaceId="script-1004",
    },
    consumeScript={
        triggerScriptId="script-1005",
        doneTriggerScriptId="script-1006",
        doneTriggerQueueNamespaceId="namespace-1001",
    },
    simpleItemAcquireScript=nil,
    simpleItemConsumeScript=nil,
    bigItemAcquireScript=nil,
    bigItemConsumeScript=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['message'])
end

result = api_result.result
item = result.item;

deleteNamespace

Delete namespace

Request

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

Result

	Type	Description
item	Namespace	Deleted namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteNamespaceRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName("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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteNamespaceRequest;
import io.gs2.inventory.result.DeleteNamespaceResult;

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

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

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

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

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

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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['message'])
end

result = api_result.result
item = result.item;

getServiceVersion

Get version of microservice

Request

	Type	Condition	Require	Default	Limitation	Description

Result

	Type	Description
item	string	Version

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetServiceVersion(
    &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetServiceVersionRequest;

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

$session->open();

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

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

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

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetServiceVersionRequest;
using Gs2.Gs2Inventory.Result.GetServiceVersionResult;

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

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

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

api_result = client.get_service_version({
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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['message'])
end

result = api_result.result
item = result.item;

dumpUserDataByUserId

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

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DumpUserDataByUserId(
    &inventory.DumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->dumpUserDataByUserId(
        (new DumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result

client = gs2('inventory')

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

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

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

result = api_result.result

checkDumpUserDataByUserId

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

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description
url	string	URL of output data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
    &inventory.CheckDumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CheckDumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkDumpUserDataByUserId(
        (new CheckDumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result
url = result.url;

client = gs2('inventory')

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

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

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

result = api_result.result
url = result.url;

cleanUserDataByUserId

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

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CleanUserDataByUserId(
    &inventory.CleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->cleanUserDataByUserId(
        (new CleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result

client = gs2('inventory')

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

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

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

result = api_result.result

checkCleanUserDataByUserId

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

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
    &inventory.CheckCleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CheckCleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkCleanUserDataByUserId(
        (new CheckCleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result

client = gs2('inventory')

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

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

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

result = api_result.result

prepareImportUserDataByUserId

Start importing data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

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

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
    &inventory.PrepareImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\PrepareImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareImportUserDataByUserId(
        (new PrepareImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

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

client = gs2('inventory')

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

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

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

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

importUserDataByUserId

Start importing data associated with the specified user ID

Request

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

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ImportUserDataByUserId(
    &inventory.ImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->importUserDataByUserId(
        (new ImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result

client = gs2('inventory')

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

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

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

result = api_result.result

checkImportUserDataByUserId

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

Request

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

Result

	Type	Description
url	string	URL of log data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
    &inventory.CheckImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CheckImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkImportUserDataByUserId(
        (new CheckImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result
url = result.url;

client = gs2('inventory')

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

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

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

result = api_result.result
url = result.url;

describeInventoryModelMasters

Get list of inventory model masters

Request

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

Result

	Type	Description
items	List<InventoryModelMaster>	List of Inventory 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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeInventoryModelMasters(
    &inventory.DescribeInventoryModelMastersRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeInventoryModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeInventoryModelMasters(
        (new DescribeInventoryModelMastersRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeInventoryModelMastersRequest;
import io.gs2.inventory.result.DescribeInventoryModelMastersResult;

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

try {
    DescribeInventoryModelMastersResult result = client.describeInventoryModelMasters(
        new DescribeInventoryModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<InventoryModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeInventoryModelMastersRequest;
using Gs2.Gs2Inventory.Result.DescribeInventoryModelMastersResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeInventoryModelMastersResult> asyncResult = null;
yield return client.DescribeInventoryModelMasters(
    new Gs2.Gs2Inventory.Request.DescribeInventoryModelMastersRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeInventoryModelMasters(
        new Gs2Inventory.DescribeInventoryModelMastersRequest()
            .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 inventory

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

try:
    result = client.describe_inventory_model_masters(
        inventory.DescribeInventoryModelMastersRequest()
            .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('inventory')

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

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

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

client = gs2('inventory')

api_result_handler = client.describe_inventory_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['message'])
end

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

createInventoryModelMaster

Create a new inventory model master

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
name	string	✓		~ 128 chars	Inventory Model Name
description	string			~ 1024 chars	Description
metadata	string			~ 128 chars	metadata
initialCapacity	int	✓		~ 2147483646	Initial Capacity
maxCapacity	int	✓		~ 2147483646	Maximum Capacity
protectReferencedItem	bool	✓	false		Item Sets with registered references cannot be deleted

Result

	Type	Description
item	InventoryModelMaster	Inventory model master created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CreateInventoryModelMaster(
    &inventory.CreateInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("item"),
        Description: nil,
        Metadata: nil,
        InitialCapacity: pointy.Int32(50),
        MaxCapacity: pointy.Int32(100),
        ProtectReferencedItem: 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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CreateInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createInventoryModelMaster(
        (new CreateInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("item")
            ->withDescription(null)
            ->withMetadata(null)
            ->withInitialCapacity(50)
            ->withMaxCapacity(100)
            ->withProtectReferencedItem(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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.CreateInventoryModelMasterRequest;
import io.gs2.inventory.result.CreateInventoryModelMasterResult;

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

try {
    CreateInventoryModelMasterResult result = client.createInventoryModelMaster(
        new CreateInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("item")
            .withDescription(null)
            .withMetadata(null)
            .withInitialCapacity(50)
            .withMaxCapacity(100)
            .withProtectReferencedItem(null)
    );
    InventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.CreateInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.CreateInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.CreateInventoryModelMasterResult> asyncResult = null;
yield return client.CreateInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.CreateInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("item")
        .WithDescription(null)
        .WithMetadata(null)
        .WithInitialCapacity(50)
        .WithMaxCapacity(100)
        .WithProtectReferencedItem(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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.createInventoryModelMaster(
        new Gs2Inventory.CreateInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("item")
            .withDescription(null)
            .withMetadata(null)
            .withInitialCapacity(50)
            .withMaxCapacity(100)
            .withProtectReferencedItem(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.create_inventory_model_master(
        inventory.CreateInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('item')
            .with_description(None)
            .with_metadata(None)
            .with_initial_capacity(50)
            .with_max_capacity(100)
            .with_protect_referenced_item(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.create_inventory_model_master({
    namespaceName="namespace-0001",
    name="item",
    description=nil,
    metadata=nil,
    initialCapacity=50,
    maxCapacity=100,
    protectReferencedItem=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.create_inventory_model_master_async({
    namespaceName="namespace-0001",
    name="item",
    description=nil,
    metadata=nil,
    initialCapacity=50,
    maxCapacity=100,
    protectReferencedItem=nil,
})

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

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

result = api_result.result
item = result.item;

getInventoryModelMaster

Get inventory model master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Inventory Model Name

Result

	Type	Description
item	InventoryModelMaster	Inventory Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetInventoryModelMaster(
    &inventory.GetInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getInventoryModelMaster(
        (new GetInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetInventoryModelMasterRequest;
import io.gs2.inventory.result.GetInventoryModelMasterResult;

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

try {
    GetInventoryModelMasterResult result = client.getInventoryModelMaster(
        new GetInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    InventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.GetInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetInventoryModelMasterResult> asyncResult = null;
yield return client.GetInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.GetInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getInventoryModelMaster(
        new Gs2Inventory.GetInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_inventory_model_master(
        inventory.GetInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

updateInventoryModelMaster

Update inventory model master

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
description	string			~ 1024 chars	Description
metadata	string			~ 128 chars	metadata
initialCapacity	int	✓		~ 2147483646	Initial Capacity
maxCapacity	int	✓		~ 2147483646	Maximum Capacity
protectReferencedItem	bool	✓	false		Item Sets with registered references cannot be deleted

Result

	Type	Description
item	InventoryModelMaster	Updated inventory model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateInventoryModelMaster(
    &inventory.UpdateInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("ITEM_INVENTORY_MASTER"),
        InitialCapacity: pointy.Int32(150),
        MaxCapacity: pointy.Int32(250),
        ProtectReferencedItem: 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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateInventoryModelMaster(
        (new UpdateInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withDescription("description1")
            ->withMetadata("ITEM_INVENTORY_MASTER")
            ->withInitialCapacity(150)
            ->withMaxCapacity(250)
            ->withProtectReferencedItem(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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateInventoryModelMasterRequest;
import io.gs2.inventory.result.UpdateInventoryModelMasterResult;

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

try {
    UpdateInventoryModelMasterResult result = client.updateInventoryModelMaster(
        new UpdateInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withDescription("description1")
            .withMetadata("ITEM_INVENTORY_MASTER")
            .withInitialCapacity(150)
            .withMaxCapacity(250)
            .withProtectReferencedItem(null)
    );
    InventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.UpdateInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateInventoryModelMasterResult> asyncResult = null;
yield return client.UpdateInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.UpdateInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithDescription("description1")
        .WithMetadata("ITEM_INVENTORY_MASTER")
        .WithInitialCapacity(150)
        .WithMaxCapacity(250)
        .WithProtectReferencedItem(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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateInventoryModelMaster(
        new Gs2Inventory.UpdateInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withDescription("description1")
            .withMetadata("ITEM_INVENTORY_MASTER")
            .withInitialCapacity(150)
            .withMaxCapacity(250)
            .withProtectReferencedItem(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.update_inventory_model_master(
        inventory.UpdateInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_description('description1')
            .with_metadata('ITEM_INVENTORY_MASTER')
            .with_initial_capacity(150)
            .with_max_capacity(250)
            .with_protect_referenced_item(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.update_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    description="description1",
    metadata="ITEM_INVENTORY_MASTER",
    initialCapacity=150,
    maxCapacity=250,
    protectReferencedItem=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    description="description1",
    metadata="ITEM_INVENTORY_MASTER",
    initialCapacity=150,
    maxCapacity=250,
    protectReferencedItem=nil,
})

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

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

result = api_result.result
item = result.item;

deleteInventoryModelMaster

Delete inventory model master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Inventory Model Name

Result

	Type	Description
item	InventoryModelMaster	Deleted inventory model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteInventoryModelMaster(
    &inventory.DeleteInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteInventoryModelMaster(
        (new DeleteInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteInventoryModelMasterRequest;
import io.gs2.inventory.result.DeleteInventoryModelMasterResult;

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

try {
    DeleteInventoryModelMasterResult result = client.deleteInventoryModelMaster(
        new DeleteInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    InventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.DeleteInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DeleteInventoryModelMasterResult> asyncResult = null;
yield return client.DeleteInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.DeleteInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.deleteInventoryModelMaster(
        new Gs2Inventory.DeleteInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.delete_inventory_model_master(
        inventory.DeleteInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

describeInventoryModels

Get list of inventory models

Request

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

Result

	Type	Description
items	List<InventoryModel>	List of Inventory Models

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeInventoryModels(
    &inventory.DescribeInventoryModelsRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeInventoryModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeInventoryModels(
        (new DescribeInventoryModelsRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeInventoryModelsRequest;
import io.gs2.inventory.result.DescribeInventoryModelsResult;

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

try {
    DescribeInventoryModelsResult result = client.describeInventoryModels(
        new DescribeInventoryModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<InventoryModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeInventoryModelsRequest;
using Gs2.Gs2Inventory.Result.DescribeInventoryModelsResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeInventoryModelsResult> asyncResult = null;
yield return client.DescribeInventoryModels(
    new Gs2.Gs2Inventory.Request.DescribeInventoryModelsRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_inventory_models(
        inventory.DescribeInventoryModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.describe_inventory_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['message'])
end

result = api_result.result
items = result.items;

getInventoryModel

Get Inventory Model

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Inventory Model Name

Result

	Type	Description
item	InventoryModel	Inventory Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetInventoryModel(
    &inventory.GetInventoryModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetInventoryModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getInventoryModel(
        (new GetInventoryModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetInventoryModelRequest;
import io.gs2.inventory.result.GetInventoryModelResult;

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

try {
    GetInventoryModelResult result = client.getInventoryModel(
        new GetInventoryModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    InventoryModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetInventoryModelRequest;
using Gs2.Gs2Inventory.Result.GetInventoryModelResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetInventoryModelResult> asyncResult = null;
yield return client.GetInventoryModel(
    new Gs2.Gs2Inventory.Request.GetInventoryModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getInventoryModel(
        new Gs2Inventory.GetInventoryModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_inventory_model(
        inventory.GetInventoryModelRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_inventory_model({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_inventory_model_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

describeItemModelMasters

Get list of item model masters

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory 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<ItemModelMaster>	List of Item 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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeItemModelMasters(
    &inventory.DescribeItemModelMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeItemModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeItemModelMasters(
        (new DescribeItemModelMastersRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeItemModelMastersRequest;
import io.gs2.inventory.result.DescribeItemModelMastersResult;

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

try {
    DescribeItemModelMastersResult result = client.describeItemModelMasters(
        new DescribeItemModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withPageToken(null)
            .withLimit(null)
    );
    List<ItemModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeItemModelMastersRequest;
using Gs2.Gs2Inventory.Result.DescribeItemModelMastersResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeItemModelMastersResult> asyncResult = null;
yield return client.DescribeItemModelMasters(
    new Gs2.Gs2Inventory.Request.DescribeItemModelMastersRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeItemModelMasters(
        new Gs2Inventory.DescribeItemModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_item_model_masters(
        inventory.DescribeItemModelMastersRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .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('inventory')

api_result = client.describe_item_model_masters({
    namespaceName="namespace-0001",
    inventoryName="item",
    pageToken=nil,
    limit=nil,
})

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

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

client = gs2('inventory')

api_result_handler = client.describe_item_model_masters_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    pageToken=nil,
    limit=nil,
})

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

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

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

createItemModelMaster

Create a new item model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	inventory model name
name	string	✓	~ 128 chars	Item Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata
stackingLimit	long	✓	1 ~ 9223372036854775805	Maximum stackable quantity
allowMultipleStacks	bool	✓		Allow items to be stored in multiple slots when the maximum stackable quantity is exceeded
sortValue	int	✓	~ 2147483646	Display order

Result

	Type	Description
item	ItemModelMaster	Item model master created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CreateItemModelMaster(
    &inventory.CreateItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        Name: pointy.String("item-master-0001"),
        Description: nil,
        Metadata: nil,
        StackingLimit: pointy.Int64(99),
        AllowMultipleStacks: pointy.Bool(false),
        SortValue: pointy.Int32(10),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CreateItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createItemModelMaster(
        (new CreateItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withName("item-master-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withStackingLimit(99)
            ->withAllowMultipleStacks(False)
            ->withSortValue(10)
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.CreateItemModelMasterRequest;
import io.gs2.inventory.result.CreateItemModelMasterResult;

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

try {
    CreateItemModelMasterResult result = client.createItemModelMaster(
        new CreateItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withName("item-master-0001")
            .withDescription(null)
            .withMetadata(null)
            .withStackingLimit(99L)
            .withAllowMultipleStacks(false)
            .withSortValue(10)
    );
    ItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.CreateItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.CreateItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.CreateItemModelMasterResult> asyncResult = null;
yield return client.CreateItemModelMaster(
    new Gs2.Gs2Inventory.Request.CreateItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithName("item-master-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithStackingLimit(99L)
        .WithAllowMultipleStacks(false)
        .WithSortValue(10),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.createItemModelMaster(
        new Gs2Inventory.CreateItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withName("item-master-0001")
            .withDescription(null)
            .withMetadata(null)
            .withStackingLimit(99)
            .withAllowMultipleStacks(false)
            .withSortValue(10)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.create_item_model_master(
        inventory.CreateItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_name('item-master-0001')
            .with_description(None)
            .with_metadata(None)
            .with_stacking_limit(99)
            .with_allow_multiple_stacks(False)
            .with_sort_value(10)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.create_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    name="item-master-0001",
    description=nil,
    metadata=nil,
    stackingLimit=99,
    allowMultipleStacks=false,
    sortValue=10,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.create_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    name="item-master-0001",
    description=nil,
    metadata=nil,
    stackingLimit=99,
    allowMultipleStacks=false,
    sortValue=10,
})

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

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

result = api_result.result
item = result.item;

getItemModelMaster

Get item model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
itemName	string	✓	~ 128 chars	Item Model Name

Result

	Type	Description
item	ItemModelMaster	Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetItemModelMaster(
    &inventory.GetItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getItemModelMaster(
        (new GetItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetItemModelMasterRequest;
import io.gs2.inventory.result.GetItemModelMasterResult;

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

try {
    GetItemModelMasterResult result = client.getItemModelMaster(
        new GetItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    ItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.GetItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetItemModelMasterResult> asyncResult = null;
yield return client.GetItemModelMaster(
    new Gs2.Gs2Inventory.Request.GetItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getItemModelMaster(
        new Gs2Inventory.GetItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_item_model_master(
        inventory.GetItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

updateItemModelMaster

Update Item Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
itemName	string	✓	~ 128 chars	Item Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata
stackingLimit	long	✓	1 ~ 9223372036854775805	Maximum stackable quantity
allowMultipleStacks	bool	✓		Allow items to be stored in multiple slots when the maximum stackable quantity is exceeded
sortValue	int	✓	~ 2147483646	Display order

Result

	Type	Description
item	ItemModelMaster	Updated Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateItemModelMaster(
    &inventory.UpdateItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("ITEM_MASTER_0001"),
        StackingLimit: pointy.Int64(49),
        AllowMultipleStacks: pointy.Bool(true),
        SortValue: pointy.Int32(30),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateItemModelMaster(
        (new UpdateItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-0001")
            ->withDescription("description1")
            ->withMetadata("ITEM_MASTER_0001")
            ->withStackingLimit(49)
            ->withAllowMultipleStacks(True)
            ->withSortValue(30)
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateItemModelMasterRequest;
import io.gs2.inventory.result.UpdateItemModelMasterResult;

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

try {
    UpdateItemModelMasterResult result = client.updateItemModelMaster(
        new UpdateItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
            .withDescription("description1")
            .withMetadata("ITEM_MASTER_0001")
            .withStackingLimit(49L)
            .withAllowMultipleStacks(true)
            .withSortValue(30)
    );
    ItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.UpdateItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateItemModelMasterResult> asyncResult = null;
yield return client.UpdateItemModelMaster(
    new Gs2.Gs2Inventory.Request.UpdateItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-0001")
        .WithDescription("description1")
        .WithMetadata("ITEM_MASTER_0001")
        .WithStackingLimit(49L)
        .WithAllowMultipleStacks(true)
        .WithSortValue(30),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateItemModelMaster(
        new Gs2Inventory.UpdateItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
            .withDescription("description1")
            .withMetadata("ITEM_MASTER_0001")
            .withStackingLimit(49)
            .withAllowMultipleStacks(true)
            .withSortValue(30)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.update_item_model_master(
        inventory.UpdateItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
            .with_description('description1')
            .with_metadata('ITEM_MASTER_0001')
            .with_stacking_limit(49)
            .with_allow_multiple_stacks(True)
            .with_sort_value(30)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.update_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
    description="description1",
    metadata="ITEM_MASTER_0001",
    stackingLimit=49,
    allowMultipleStacks=true,
    sortValue=30,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
    description="description1",
    metadata="ITEM_MASTER_0001",
    stackingLimit=49,
    allowMultipleStacks=true,
    sortValue=30,
})

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

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

result = api_result.result
item = result.item;

deleteItemModelMaster

Delete Item Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
itemName	string	✓	~ 128 chars	Item Model Name

Result

	Type	Description
item	ItemModelMaster	Deleted Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteItemModelMaster(
    &inventory.DeleteItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteItemModelMaster(
        (new DeleteItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteItemModelMasterRequest;
import io.gs2.inventory.result.DeleteItemModelMasterResult;

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

try {
    DeleteItemModelMasterResult result = client.deleteItemModelMaster(
        new DeleteItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    ItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.DeleteItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DeleteItemModelMasterResult> asyncResult = null;
yield return client.DeleteItemModelMaster(
    new Gs2.Gs2Inventory.Request.DeleteItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.deleteItemModelMaster(
        new Gs2Inventory.DeleteItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.delete_item_model_master(
        inventory.DeleteItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

describeItemModels

Get list of item models

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Inventory Model Name

Result

	Type	Description
items	List<ItemModel>	List of Item Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeItemModels(
    &inventory.DescribeItemModelsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeItemModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeItemModels(
        (new DescribeItemModelsRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeItemModelsRequest;
import io.gs2.inventory.result.DescribeItemModelsResult;

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

try {
    DescribeItemModelsResult result = client.describeItemModels(
        new DescribeItemModelsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    List<ItemModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeItemModelsRequest;
using Gs2.Gs2Inventory.Result.DescribeItemModelsResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeItemModelsResult> asyncResult = null;
yield return client.DescribeItemModels(
    new Gs2.Gs2Inventory.Request.DescribeItemModelsRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeItemModels(
        new Gs2Inventory.DescribeItemModelsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_item_models(
        inventory.DescribeItemModelsRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_item_models({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.describe_item_models_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
items = result.items;

getItemModel

Get item model

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
itemName	string	✓	~ 128 chars	Item Model Name

Result

	Type	Description
item	ItemModel

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetItemModel(
    &inventory.GetItemModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetItemModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getItemModel(
        (new GetItemModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetItemModelRequest;
import io.gs2.inventory.result.GetItemModelResult;

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

try {
    GetItemModelResult result = client.getItemModel(
        new GetItemModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    ItemModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetItemModelRequest;
using Gs2.Gs2Inventory.Result.GetItemModelResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetItemModelResult> asyncResult = null;
yield return client.GetItemModel(
    new Gs2.Gs2Inventory.Request.GetItemModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getItemModel(
        new Gs2Inventory.GetItemModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_item_model(
        inventory.GetItemModelRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_item_model({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_item_model_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

describeSimpleInventoryModelMasters

Get list of inventory model masters

Request

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

Result

	Type	Description
items	List<SimpleInventoryModelMaster>	List of Simple Inventory 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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeSimpleInventoryModelMasters(
    &inventory.DescribeSimpleInventoryModelMastersRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeSimpleInventoryModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSimpleInventoryModelMasters(
        (new DescribeSimpleInventoryModelMastersRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeSimpleInventoryModelMastersRequest;
import io.gs2.inventory.result.DescribeSimpleInventoryModelMastersResult;

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

try {
    DescribeSimpleInventoryModelMastersResult result = client.describeSimpleInventoryModelMasters(
        new DescribeSimpleInventoryModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<SimpleInventoryModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeSimpleInventoryModelMastersRequest;
using Gs2.Gs2Inventory.Result.DescribeSimpleInventoryModelMastersResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeSimpleInventoryModelMastersResult> asyncResult = null;
yield return client.DescribeSimpleInventoryModelMasters(
    new Gs2.Gs2Inventory.Request.DescribeSimpleInventoryModelMastersRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeSimpleInventoryModelMasters(
        new Gs2Inventory.DescribeSimpleInventoryModelMastersRequest()
            .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 inventory

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

try:
    result = client.describe_simple_inventory_model_masters(
        inventory.DescribeSimpleInventoryModelMastersRequest()
            .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('inventory')

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

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

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

client = gs2('inventory')

api_result_handler = client.describe_simple_inventory_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['message'])
end

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

createSimpleInventoryModelMaster

Create a new inventory model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
name	string	✓	~ 128 chars	Simple Inventory Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	SimpleInventoryModelMaster	Inventory model master created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CreateSimpleInventoryModelMaster(
    &inventory.CreateSimpleInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("item"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CreateSimpleInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createSimpleInventoryModelMaster(
        (new CreateSimpleInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("item")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.CreateSimpleInventoryModelMasterRequest;
import io.gs2.inventory.result.CreateSimpleInventoryModelMasterResult;

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

try {
    CreateSimpleInventoryModelMasterResult result = client.createSimpleInventoryModelMaster(
        new CreateSimpleInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("item")
            .withDescription(null)
            .withMetadata(null)
    );
    SimpleInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.CreateSimpleInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.CreateSimpleInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.CreateSimpleInventoryModelMasterResult> asyncResult = null;
yield return client.CreateSimpleInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.CreateSimpleInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("item")
        .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 Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.create_simple_inventory_model_master(
        inventory.CreateSimpleInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('item')
            .with_description(None)
            .with_metadata(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.create_simple_inventory_model_master({
    namespaceName="namespace-0001",
    name="item",
    description=nil,
    metadata=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.create_simple_inventory_model_master_async({
    namespaceName="namespace-0001",
    name="item",
    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['message'])
end

result = api_result.result
item = result.item;

getSimpleInventoryModelMaster

Get inventory model master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Simple Inventory Model Name

Result

	Type	Description
item	SimpleInventoryModelMaster	Simple Inventory Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleInventoryModelMaster(
    &inventory.GetSimpleInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleInventoryModelMaster(
        (new GetSimpleInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleInventoryModelMasterRequest;
import io.gs2.inventory.result.GetSimpleInventoryModelMasterResult;

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

try {
    GetSimpleInventoryModelMasterResult result = client.getSimpleInventoryModelMaster(
        new GetSimpleInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    SimpleInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.GetSimpleInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleInventoryModelMasterResult> asyncResult = null;
yield return client.GetSimpleInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.GetSimpleInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getSimpleInventoryModelMaster(
        new Gs2Inventory.GetSimpleInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_simple_inventory_model_master(
        inventory.GetSimpleInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_simple_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

updateSimpleInventoryModelMaster

Update inventory model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	SimpleInventoryModelMaster	Updated inventory model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateSimpleInventoryModelMaster(
    &inventory.UpdateSimpleInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("ITEM_INVENTORY_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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateSimpleInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateSimpleInventoryModelMaster(
        (new UpdateSimpleInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withDescription("description1")
            ->withMetadata("ITEM_INVENTORY_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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateSimpleInventoryModelMasterRequest;
import io.gs2.inventory.result.UpdateSimpleInventoryModelMasterResult;

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

try {
    UpdateSimpleInventoryModelMasterResult result = client.updateSimpleInventoryModelMaster(
        new UpdateSimpleInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withDescription("description1")
            .withMetadata("ITEM_INVENTORY_MASTER")
    );
    SimpleInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateSimpleInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.UpdateSimpleInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateSimpleInventoryModelMasterResult> asyncResult = null;
yield return client.UpdateSimpleInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.UpdateSimpleInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithDescription("description1")
        .WithMetadata("ITEM_INVENTORY_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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateSimpleInventoryModelMaster(
        new Gs2Inventory.UpdateSimpleInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withDescription("description1")
            .withMetadata("ITEM_INVENTORY_MASTER")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.update_simple_inventory_model_master(
        inventory.UpdateSimpleInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_description('description1')
            .with_metadata('ITEM_INVENTORY_MASTER')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.update_simple_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    description="description1",
    metadata="ITEM_INVENTORY_MASTER",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_simple_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    description="description1",
    metadata="ITEM_INVENTORY_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['message'])
end

result = api_result.result
item = result.item;

deleteSimpleInventoryModelMaster

Delete inventory model master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Simple Inventory Model Name

Result

	Type	Description
item	SimpleInventoryModelMaster	Deleted inventory model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteSimpleInventoryModelMaster(
    &inventory.DeleteSimpleInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteSimpleInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteSimpleInventoryModelMaster(
        (new DeleteSimpleInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteSimpleInventoryModelMasterRequest;
import io.gs2.inventory.result.DeleteSimpleInventoryModelMasterResult;

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

try {
    DeleteSimpleInventoryModelMasterResult result = client.deleteSimpleInventoryModelMaster(
        new DeleteSimpleInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    SimpleInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteSimpleInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.DeleteSimpleInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DeleteSimpleInventoryModelMasterResult> asyncResult = null;
yield return client.DeleteSimpleInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.DeleteSimpleInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.deleteSimpleInventoryModelMaster(
        new Gs2Inventory.DeleteSimpleInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.delete_simple_inventory_model_master(
        inventory.DeleteSimpleInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_simple_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_simple_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

describeSimpleInventoryModels

Get list of inventory models

Request

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

Result

	Type	Description
items	List<SimpleInventoryModel>	List of Simple Inventory Models

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeSimpleInventoryModels(
    &inventory.DescribeSimpleInventoryModelsRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeSimpleInventoryModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSimpleInventoryModels(
        (new DescribeSimpleInventoryModelsRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeSimpleInventoryModelsRequest;
import io.gs2.inventory.result.DescribeSimpleInventoryModelsResult;

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

try {
    DescribeSimpleInventoryModelsResult result = client.describeSimpleInventoryModels(
        new DescribeSimpleInventoryModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<SimpleInventoryModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeSimpleInventoryModelsRequest;
using Gs2.Gs2Inventory.Result.DescribeSimpleInventoryModelsResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeSimpleInventoryModelsResult> asyncResult = null;
yield return client.DescribeSimpleInventoryModels(
    new Gs2.Gs2Inventory.Request.DescribeSimpleInventoryModelsRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_simple_inventory_models(
        inventory.DescribeSimpleInventoryModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.describe_simple_inventory_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['message'])
end

result = api_result.result
items = result.items;

getSimpleInventoryModel

Get Simple Inventory Model

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Simple Inventory Model Name

Result

	Type	Description
item	SimpleInventoryModel	Simple Inventory Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleInventoryModel(
    &inventory.GetSimpleInventoryModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleInventoryModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleInventoryModel(
        (new GetSimpleInventoryModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleInventoryModelRequest;
import io.gs2.inventory.result.GetSimpleInventoryModelResult;

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

try {
    GetSimpleInventoryModelResult result = client.getSimpleInventoryModel(
        new GetSimpleInventoryModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    SimpleInventoryModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleInventoryModelRequest;
using Gs2.Gs2Inventory.Result.GetSimpleInventoryModelResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleInventoryModelResult> asyncResult = null;
yield return client.GetSimpleInventoryModel(
    new Gs2.Gs2Inventory.Request.GetSimpleInventoryModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getSimpleInventoryModel(
        new Gs2Inventory.GetSimpleInventoryModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_simple_inventory_model(
        inventory.GetSimpleInventoryModelRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_inventory_model({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_simple_inventory_model_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

describeSimpleItemModelMasters

Get list of item model masters

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Simple Inventory 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<SimpleItemModelMaster>	List of Simple Item 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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeSimpleItemModelMasters(
    &inventory.DescribeSimpleItemModelMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeSimpleItemModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSimpleItemModelMasters(
        (new DescribeSimpleItemModelMastersRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeSimpleItemModelMastersRequest;
import io.gs2.inventory.result.DescribeSimpleItemModelMastersResult;

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

try {
    DescribeSimpleItemModelMastersResult result = client.describeSimpleItemModelMasters(
        new DescribeSimpleItemModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withPageToken(null)
            .withLimit(null)
    );
    List<SimpleItemModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeSimpleItemModelMastersRequest;
using Gs2.Gs2Inventory.Result.DescribeSimpleItemModelMastersResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeSimpleItemModelMastersResult> asyncResult = null;
yield return client.DescribeSimpleItemModelMasters(
    new Gs2.Gs2Inventory.Request.DescribeSimpleItemModelMastersRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeSimpleItemModelMasters(
        new Gs2Inventory.DescribeSimpleItemModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_simple_item_model_masters(
        inventory.DescribeSimpleItemModelMastersRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .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('inventory')

api_result = client.describe_simple_item_model_masters({
    namespaceName="namespace-0001",
    inventoryName="item",
    pageToken=nil,
    limit=nil,
})

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

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

client = gs2('inventory')

api_result_handler = client.describe_simple_item_model_masters_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    pageToken=nil,
    limit=nil,
})

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

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

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

createSimpleItemModelMaster

Create a new item model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
name	string	✓	~ 128 chars	Simple Item Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	SimpleItemModelMaster	Item model master created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CreateSimpleItemModelMaster(
    &inventory.CreateSimpleItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        Name: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CreateSimpleItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createSimpleItemModelMaster(
        (new CreateSimpleItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.CreateSimpleItemModelMasterRequest;
import io.gs2.inventory.result.CreateSimpleItemModelMasterResult;

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

try {
    CreateSimpleItemModelMasterResult result = client.createSimpleItemModelMaster(
        new CreateSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withName("item-master-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    SimpleItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.CreateSimpleItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.CreateSimpleItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.CreateSimpleItemModelMasterResult> asyncResult = null;
yield return client.CreateSimpleItemModelMaster(
    new Gs2.Gs2Inventory.Request.CreateSimpleItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.createSimpleItemModelMaster(
        new Gs2Inventory.CreateSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withName("item-master-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.create_simple_item_model_master(
        inventory.CreateSimpleItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_name('item-master-0001')
            .with_description(None)
            .with_metadata(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.create_simple_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    name="item-master-0001",
    description=nil,
    metadata=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.create_simple_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    name="item-master-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['message'])
end

result = api_result.result
item = result.item;

getSimpleItemModelMaster

Get item model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
itemName	string	✓	~ 128 chars	Simple Item Model Name

Result

	Type	Description
item	SimpleItemModelMaster	Simple Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleItemModelMaster(
    &inventory.GetSimpleItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleItemModelMaster(
        (new GetSimpleItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleItemModelMasterRequest;
import io.gs2.inventory.result.GetSimpleItemModelMasterResult;

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

try {
    GetSimpleItemModelMasterResult result = client.getSimpleItemModelMaster(
        new GetSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    SimpleItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.GetSimpleItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleItemModelMasterResult> asyncResult = null;
yield return client.GetSimpleItemModelMaster(
    new Gs2.Gs2Inventory.Request.GetSimpleItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getSimpleItemModelMaster(
        new Gs2Inventory.GetSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_simple_item_model_master(
        inventory.GetSimpleItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_simple_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

updateSimpleItemModelMaster

Update Simple Item Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
itemName	string	✓	~ 128 chars	Simple Item Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	SimpleItemModelMaster	Updated Simple Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateSimpleItemModelMaster(
    &inventory.UpdateSimpleItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("ITEM_MASTER_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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateSimpleItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateSimpleItemModelMaster(
        (new UpdateSimpleItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-0001")
            ->withDescription("description1")
            ->withMetadata("ITEM_MASTER_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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateSimpleItemModelMasterRequest;
import io.gs2.inventory.result.UpdateSimpleItemModelMasterResult;

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

try {
    UpdateSimpleItemModelMasterResult result = client.updateSimpleItemModelMaster(
        new UpdateSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
            .withDescription("description1")
            .withMetadata("ITEM_MASTER_0001")
    );
    SimpleItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateSimpleItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.UpdateSimpleItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateSimpleItemModelMasterResult> asyncResult = null;
yield return client.UpdateSimpleItemModelMaster(
    new Gs2.Gs2Inventory.Request.UpdateSimpleItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-0001")
        .WithDescription("description1")
        .WithMetadata("ITEM_MASTER_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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateSimpleItemModelMaster(
        new Gs2Inventory.UpdateSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
            .withDescription("description1")
            .withMetadata("ITEM_MASTER_0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.update_simple_item_model_master(
        inventory.UpdateSimpleItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
            .with_description('description1')
            .with_metadata('ITEM_MASTER_0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.update_simple_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
    description="description1",
    metadata="ITEM_MASTER_0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_simple_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
    description="description1",
    metadata="ITEM_MASTER_0001",
})

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

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

result = api_result.result
item = result.item;

deleteSimpleItemModelMaster

Delete Simple Item Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
itemName	string	✓	~ 128 chars	Simple Item Model Name

Result

	Type	Description
item	SimpleItemModelMaster	Deleted Simple Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteSimpleItemModelMaster(
    &inventory.DeleteSimpleItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteSimpleItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteSimpleItemModelMaster(
        (new DeleteSimpleItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteSimpleItemModelMasterRequest;
import io.gs2.inventory.result.DeleteSimpleItemModelMasterResult;

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

try {
    DeleteSimpleItemModelMasterResult result = client.deleteSimpleItemModelMaster(
        new DeleteSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    SimpleItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteSimpleItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.DeleteSimpleItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DeleteSimpleItemModelMasterResult> asyncResult = null;
yield return client.DeleteSimpleItemModelMaster(
    new Gs2.Gs2Inventory.Request.DeleteSimpleItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.deleteSimpleItemModelMaster(
        new Gs2Inventory.DeleteSimpleItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.delete_simple_item_model_master(
        inventory.DeleteSimpleItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_simple_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_simple_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

describeSimpleItemModels

Get list of item models

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Simple Inventory Model Name

Result

	Type	Description
items	List<SimpleItemModel>	List of Simple Item Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeSimpleItemModels(
    &inventory.DescribeSimpleItemModelsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeSimpleItemModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSimpleItemModels(
        (new DescribeSimpleItemModelsRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeSimpleItemModelsRequest;
import io.gs2.inventory.result.DescribeSimpleItemModelsResult;

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

try {
    DescribeSimpleItemModelsResult result = client.describeSimpleItemModels(
        new DescribeSimpleItemModelsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    List<SimpleItemModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeSimpleItemModelsRequest;
using Gs2.Gs2Inventory.Result.DescribeSimpleItemModelsResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeSimpleItemModelsResult> asyncResult = null;
yield return client.DescribeSimpleItemModels(
    new Gs2.Gs2Inventory.Request.DescribeSimpleItemModelsRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeSimpleItemModels(
        new Gs2Inventory.DescribeSimpleItemModelsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_simple_item_models(
        inventory.DescribeSimpleItemModelsRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_simple_item_models({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.describe_simple_item_models_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
items = result.items;

getSimpleItemModel

Get item model

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
itemName	string	✓	~ 128 chars	Simple Item Model Name

Result

	Type	Description
item	SimpleItemModel

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleItemModel(
    &inventory.GetSimpleItemModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleItemModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleItemModel(
        (new GetSimpleItemModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleItemModelRequest;
import io.gs2.inventory.result.GetSimpleItemModelResult;

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

try {
    GetSimpleItemModelResult result = client.getSimpleItemModel(
        new GetSimpleItemModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    SimpleItemModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleItemModelRequest;
using Gs2.Gs2Inventory.Result.GetSimpleItemModelResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleItemModelResult> asyncResult = null;
yield return client.GetSimpleItemModel(
    new Gs2.Gs2Inventory.Request.GetSimpleItemModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getSimpleItemModel(
        new Gs2Inventory.GetSimpleItemModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_simple_item_model(
        inventory.GetSimpleItemModelRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_item_model({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_simple_item_model_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

describeBigInventoryModelMasters

Get list of inventory model masters

Request

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

Result

	Type	Description
items	List<BigInventoryModelMaster>	List of Big Inventory 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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeBigInventoryModelMasters(
    &inventory.DescribeBigInventoryModelMastersRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeBigInventoryModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBigInventoryModelMasters(
        (new DescribeBigInventoryModelMastersRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeBigInventoryModelMastersRequest;
import io.gs2.inventory.result.DescribeBigInventoryModelMastersResult;

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

try {
    DescribeBigInventoryModelMastersResult result = client.describeBigInventoryModelMasters(
        new DescribeBigInventoryModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<BigInventoryModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeBigInventoryModelMastersRequest;
using Gs2.Gs2Inventory.Result.DescribeBigInventoryModelMastersResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeBigInventoryModelMastersResult> asyncResult = null;
yield return client.DescribeBigInventoryModelMasters(
    new Gs2.Gs2Inventory.Request.DescribeBigInventoryModelMastersRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeBigInventoryModelMasters(
        new Gs2Inventory.DescribeBigInventoryModelMastersRequest()
            .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 inventory

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

try:
    result = client.describe_big_inventory_model_masters(
        inventory.DescribeBigInventoryModelMastersRequest()
            .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('inventory')

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

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

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

client = gs2('inventory')

api_result_handler = client.describe_big_inventory_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['message'])
end

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

createBigInventoryModelMaster

Create a new inventory model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
name	string	✓	~ 128 chars	Big Inventory Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	BigInventoryModelMaster	Inventory model master created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CreateBigInventoryModelMaster(
    &inventory.CreateBigInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("item"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CreateBigInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createBigInventoryModelMaster(
        (new CreateBigInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("item")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.CreateBigInventoryModelMasterRequest;
import io.gs2.inventory.result.CreateBigInventoryModelMasterResult;

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

try {
    CreateBigInventoryModelMasterResult result = client.createBigInventoryModelMaster(
        new CreateBigInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("item")
            .withDescription(null)
            .withMetadata(null)
    );
    BigInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.CreateBigInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.CreateBigInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.CreateBigInventoryModelMasterResult> asyncResult = null;
yield return client.CreateBigInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.CreateBigInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("item")
        .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 Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.create_big_inventory_model_master(
        inventory.CreateBigInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('item')
            .with_description(None)
            .with_metadata(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.create_big_inventory_model_master({
    namespaceName="namespace-0001",
    name="item",
    description=nil,
    metadata=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.create_big_inventory_model_master_async({
    namespaceName="namespace-0001",
    name="item",
    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['message'])
end

result = api_result.result
item = result.item;

getBigInventoryModelMaster

Get inventory model master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Big Inventory Model Name

Result

	Type	Description
item	BigInventoryModelMaster	Big Inventory Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetBigInventoryModelMaster(
    &inventory.GetBigInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetBigInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBigInventoryModelMaster(
        (new GetBigInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetBigInventoryModelMasterRequest;
import io.gs2.inventory.result.GetBigInventoryModelMasterResult;

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

try {
    GetBigInventoryModelMasterResult result = client.getBigInventoryModelMaster(
        new GetBigInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    BigInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetBigInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.GetBigInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetBigInventoryModelMasterResult> asyncResult = null;
yield return client.GetBigInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.GetBigInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getBigInventoryModelMaster(
        new Gs2Inventory.GetBigInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_big_inventory_model_master(
        inventory.GetBigInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_big_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_big_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

updateBigInventoryModelMaster

Update inventory model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	BigInventoryModelMaster	Updated inventory model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateBigInventoryModelMaster(
    &inventory.UpdateBigInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("ITEM_INVENTORY_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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateBigInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateBigInventoryModelMaster(
        (new UpdateBigInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withDescription("description1")
            ->withMetadata("ITEM_INVENTORY_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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateBigInventoryModelMasterRequest;
import io.gs2.inventory.result.UpdateBigInventoryModelMasterResult;

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

try {
    UpdateBigInventoryModelMasterResult result = client.updateBigInventoryModelMaster(
        new UpdateBigInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withDescription("description1")
            .withMetadata("ITEM_INVENTORY_MASTER")
    );
    BigInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateBigInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.UpdateBigInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateBigInventoryModelMasterResult> asyncResult = null;
yield return client.UpdateBigInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.UpdateBigInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithDescription("description1")
        .WithMetadata("ITEM_INVENTORY_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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateBigInventoryModelMaster(
        new Gs2Inventory.UpdateBigInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withDescription("description1")
            .withMetadata("ITEM_INVENTORY_MASTER")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.update_big_inventory_model_master(
        inventory.UpdateBigInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_description('description1')
            .with_metadata('ITEM_INVENTORY_MASTER')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.update_big_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    description="description1",
    metadata="ITEM_INVENTORY_MASTER",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_big_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    description="description1",
    metadata="ITEM_INVENTORY_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['message'])
end

result = api_result.result
item = result.item;

deleteBigInventoryModelMaster

Delete inventory model master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Big Inventory Model Name

Result

	Type	Description
item	BigInventoryModelMaster	Deleted inventory model master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteBigInventoryModelMaster(
    &inventory.DeleteBigInventoryModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteBigInventoryModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteBigInventoryModelMaster(
        (new DeleteBigInventoryModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteBigInventoryModelMasterRequest;
import io.gs2.inventory.result.DeleteBigInventoryModelMasterResult;

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

try {
    DeleteBigInventoryModelMasterResult result = client.deleteBigInventoryModelMaster(
        new DeleteBigInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    BigInventoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteBigInventoryModelMasterRequest;
using Gs2.Gs2Inventory.Result.DeleteBigInventoryModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DeleteBigInventoryModelMasterResult> asyncResult = null;
yield return client.DeleteBigInventoryModelMaster(
    new Gs2.Gs2Inventory.Request.DeleteBigInventoryModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.deleteBigInventoryModelMaster(
        new Gs2Inventory.DeleteBigInventoryModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.delete_big_inventory_model_master(
        inventory.DeleteBigInventoryModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_big_inventory_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_big_inventory_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

describeBigInventoryModels

Get list of inventory models

Request

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

Result

	Type	Description
items	List<BigInventoryModel>	List of Big Inventory Models

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeBigInventoryModels(
    &inventory.DescribeBigInventoryModelsRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeBigInventoryModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBigInventoryModels(
        (new DescribeBigInventoryModelsRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeBigInventoryModelsRequest;
import io.gs2.inventory.result.DescribeBigInventoryModelsResult;

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

try {
    DescribeBigInventoryModelsResult result = client.describeBigInventoryModels(
        new DescribeBigInventoryModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<BigInventoryModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeBigInventoryModelsRequest;
using Gs2.Gs2Inventory.Result.DescribeBigInventoryModelsResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeBigInventoryModelsResult> asyncResult = null;
yield return client.DescribeBigInventoryModels(
    new Gs2.Gs2Inventory.Request.DescribeBigInventoryModelsRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_big_inventory_models(
        inventory.DescribeBigInventoryModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.describe_big_inventory_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['message'])
end

result = api_result.result
items = result.items;

getBigInventoryModel

Get Big Inventory Model

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Big Inventory Model Name

Result

	Type	Description
item	BigInventoryModel	Big Inventory Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetBigInventoryModel(
    &inventory.GetBigInventoryModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetBigInventoryModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBigInventoryModel(
        (new GetBigInventoryModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetBigInventoryModelRequest;
import io.gs2.inventory.result.GetBigInventoryModelResult;

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

try {
    GetBigInventoryModelResult result = client.getBigInventoryModel(
        new GetBigInventoryModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    BigInventoryModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetBigInventoryModelRequest;
using Gs2.Gs2Inventory.Result.GetBigInventoryModelResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetBigInventoryModelResult> asyncResult = null;
yield return client.GetBigInventoryModel(
    new Gs2.Gs2Inventory.Request.GetBigInventoryModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getBigInventoryModel(
        new Gs2Inventory.GetBigInventoryModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_big_inventory_model(
        inventory.GetBigInventoryModelRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_big_inventory_model({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_big_inventory_model_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
item = result.item;

describeBigItemModelMasters

Get list of item model masters

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Big Inventory 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<BigItemModelMaster>	List of Big Item 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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeBigItemModelMasters(
    &inventory.DescribeBigItemModelMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeBigItemModelMastersRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBigItemModelMasters(
        (new DescribeBigItemModelMastersRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeBigItemModelMastersRequest;
import io.gs2.inventory.result.DescribeBigItemModelMastersResult;

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

try {
    DescribeBigItemModelMastersResult result = client.describeBigItemModelMasters(
        new DescribeBigItemModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withPageToken(null)
            .withLimit(null)
    );
    List<BigItemModelMaster> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeBigItemModelMastersRequest;
using Gs2.Gs2Inventory.Result.DescribeBigItemModelMastersResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeBigItemModelMastersResult> asyncResult = null;
yield return client.DescribeBigItemModelMasters(
    new Gs2.Gs2Inventory.Request.DescribeBigItemModelMastersRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeBigItemModelMasters(
        new Gs2Inventory.DescribeBigItemModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_big_item_model_masters(
        inventory.DescribeBigItemModelMastersRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .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('inventory')

api_result = client.describe_big_item_model_masters({
    namespaceName="namespace-0001",
    inventoryName="item",
    pageToken=nil,
    limit=nil,
})

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

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

client = gs2('inventory')

api_result_handler = client.describe_big_item_model_masters_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    pageToken=nil,
    limit=nil,
})

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

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

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

createBigItemModelMaster

Create a new item model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
name	string	✓	~ 128 chars	Big Item Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	BigItemModelMaster	Item model master created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.CreateBigItemModelMaster(
    &inventory.CreateBigItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        Name: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\CreateBigItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createBigItemModelMaster(
        (new CreateBigItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.CreateBigItemModelMasterRequest;
import io.gs2.inventory.result.CreateBigItemModelMasterResult;

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

try {
    CreateBigItemModelMasterResult result = client.createBigItemModelMaster(
        new CreateBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withName("item-master-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    BigItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.CreateBigItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.CreateBigItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.CreateBigItemModelMasterResult> asyncResult = null;
yield return client.CreateBigItemModelMaster(
    new Gs2.Gs2Inventory.Request.CreateBigItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.createBigItemModelMaster(
        new Gs2Inventory.CreateBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withName("item-master-0001")
            .withDescription(null)
            .withMetadata(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.create_big_item_model_master(
        inventory.CreateBigItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_name('item-master-0001')
            .with_description(None)
            .with_metadata(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.create_big_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    name="item-master-0001",
    description=nil,
    metadata=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.create_big_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    name="item-master-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['message'])
end

result = api_result.result
item = result.item;

getBigItemModelMaster

Get item model master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
itemName	string	✓	~ 128 chars	Big Item Model Name

Result

	Type	Description
item	BigItemModelMaster	Big Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetBigItemModelMaster(
    &inventory.GetBigItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetBigItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBigItemModelMaster(
        (new GetBigItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetBigItemModelMasterRequest;
import io.gs2.inventory.result.GetBigItemModelMasterResult;

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

try {
    GetBigItemModelMasterResult result = client.getBigItemModelMaster(
        new GetBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    BigItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetBigItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.GetBigItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetBigItemModelMasterResult> asyncResult = null;
yield return client.GetBigItemModelMaster(
    new Gs2.Gs2Inventory.Request.GetBigItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getBigItemModelMaster(
        new Gs2Inventory.GetBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_big_item_model_master(
        inventory.GetBigItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_big_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_big_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

updateBigItemModelMaster

Update Big Item Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
itemName	string	✓	~ 128 chars	Big Item Model Name
description	string		~ 1024 chars	Description
metadata	string		~ 128 chars	metadata

Result

	Type	Description
item	BigItemModelMaster	Updated Big Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateBigItemModelMaster(
    &inventory.UpdateBigItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-0001"),
        Description: pointy.String("description1"),
        Metadata: pointy.String("ITEM_MASTER_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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateBigItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateBigItemModelMaster(
        (new UpdateBigItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-0001")
            ->withDescription("description1")
            ->withMetadata("ITEM_MASTER_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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateBigItemModelMasterRequest;
import io.gs2.inventory.result.UpdateBigItemModelMasterResult;

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

try {
    UpdateBigItemModelMasterResult result = client.updateBigItemModelMaster(
        new UpdateBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
            .withDescription("description1")
            .withMetadata("ITEM_MASTER_0001")
    );
    BigItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateBigItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.UpdateBigItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateBigItemModelMasterResult> asyncResult = null;
yield return client.UpdateBigItemModelMaster(
    new Gs2.Gs2Inventory.Request.UpdateBigItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-0001")
        .WithDescription("description1")
        .WithMetadata("ITEM_MASTER_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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateBigItemModelMaster(
        new Gs2Inventory.UpdateBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
            .withDescription("description1")
            .withMetadata("ITEM_MASTER_0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.update_big_item_model_master(
        inventory.UpdateBigItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
            .with_description('description1')
            .with_metadata('ITEM_MASTER_0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.update_big_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
    description="description1",
    metadata="ITEM_MASTER_0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_big_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
    description="description1",
    metadata="ITEM_MASTER_0001",
})

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

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

result = api_result.result
item = result.item;

deleteBigItemModelMaster

Delete Big Item Model Master

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
itemName	string	✓	~ 128 chars	Big Item Model Name

Result

	Type	Description
item	BigItemModelMaster	Deleted Big Item Model Master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteBigItemModelMaster(
    &inventory.DeleteBigItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteBigItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteBigItemModelMaster(
        (new DeleteBigItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteBigItemModelMasterRequest;
import io.gs2.inventory.result.DeleteBigItemModelMasterResult;

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

try {
    DeleteBigItemModelMasterResult result = client.deleteBigItemModelMaster(
        new DeleteBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    BigItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteBigItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.DeleteBigItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DeleteBigItemModelMasterResult> asyncResult = null;
yield return client.DeleteBigItemModelMaster(
    new Gs2.Gs2Inventory.Request.DeleteBigItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.deleteBigItemModelMaster(
        new Gs2Inventory.DeleteBigItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.delete_big_item_model_master(
        inventory.DeleteBigItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_big_item_model_master({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_big_item_model_master_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

describeBigItemModels

Get list of item models

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
inventoryName	string		✓		~ 128 chars	Big Inventory Model Name

Result

	Type	Description
items	List<BigItemModel>	List of Big Item Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeBigItemModels(
    &inventory.DescribeBigItemModelsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeBigItemModelsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBigItemModels(
        (new DescribeBigItemModelsRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeBigItemModelsRequest;
import io.gs2.inventory.result.DescribeBigItemModelsResult;

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

try {
    DescribeBigItemModelsResult result = client.describeBigItemModels(
        new DescribeBigItemModelsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    List<BigItemModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeBigItemModelsRequest;
using Gs2.Gs2Inventory.Result.DescribeBigItemModelsResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DescribeBigItemModelsResult> asyncResult = null;
yield return client.DescribeBigItemModels(
    new Gs2.Gs2Inventory.Request.DescribeBigItemModelsRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item"),
    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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.describeBigItemModels(
        new Gs2Inventory.DescribeBigItemModelsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_big_item_models(
        inventory.DescribeBigItemModelsRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_big_item_models({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.describe_big_item_models_async({
    namespaceName="namespace-0001",
    inventoryName="item",
})

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

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

result = api_result.result
items = result.items;

getBigItemModel

Get item model

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
itemName	string	✓	~ 128 chars	Big Item Model Name

Result

	Type	Description
item	BigItemModel

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetBigItemModel(
    &inventory.GetBigItemModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-master-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetBigItemModelRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBigItemModel(
        (new GetBigItemModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-master-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetBigItemModelRequest;
import io.gs2.inventory.result.GetBigItemModelResult;

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

try {
    GetBigItemModelResult result = client.getBigItemModel(
        new GetBigItemModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    BigItemModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetBigItemModelRequest;
using Gs2.Gs2Inventory.Result.GetBigItemModelResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetBigItemModelResult> asyncResult = null;
yield return client.GetBigItemModel(
    new Gs2.Gs2Inventory.Request.GetBigItemModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-master-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getBigItemModel(
        new Gs2Inventory.GetBigItemModelRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-master-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_big_item_model(
        inventory.GetBigItemModelRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-master-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_big_item_model({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_big_item_model_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-master-0001",
})

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

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

result = api_result.result
item = result.item;

exportMaster

Export master data for the currently available possession master

Request

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

Result

	Type	Description
item	CurrentItemModelMaster	Currently available possession master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ExportMaster(
    &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ExportMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->exportMaster(
        (new ExportMasterRequest())
            ->withNamespaceName("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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ExportMasterRequest;
import io.gs2.inventory.result.ExportMasterResult;

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

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

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

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

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

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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['message'])
end

result = api_result.result
item = result.item;

getCurrentItemModelMaster

Retrieve the currently available possession master

Request

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

Result

	Type	Description
item	CurrentItemModelMaster	Currently available possession master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetCurrentItemModelMaster(
    &inventory.GetCurrentItemModelMasterRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetCurrentItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getCurrentItemModelMaster(
        (new GetCurrentItemModelMasterRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetCurrentItemModelMasterRequest;
import io.gs2.inventory.result.GetCurrentItemModelMasterResult;

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

try {
    GetCurrentItemModelMasterResult result = client.getCurrentItemModelMaster(
        new GetCurrentItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetCurrentItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.GetCurrentItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetCurrentItemModelMasterResult> asyncResult = null;
yield return client.GetCurrentItemModelMaster(
    new Gs2.Gs2Inventory.Request.GetCurrentItemModelMasterRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_current_item_model_master(
        inventory.GetCurrentItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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

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

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

result = api_result.result
item = result.item;

preUpdateCurrentItemModelMaster

Update the currently available model settings

Request

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

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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.PreUpdateCurrentItemModelMaster(
    &inventory.PreUpdateCurrentItemModelMasterRequest {
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\PreUpdateCurrentItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentItemModelMaster(
        (new PreUpdateCurrentItemModelMasterRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.PreUpdateCurrentItemModelMasterRequest;
import io.gs2.inventory.result.PreUpdateCurrentItemModelMasterResult;

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

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

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.PreUpdateCurrentItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.PreUpdateCurrentItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.PreUpdateCurrentItemModelMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentItemModelMaster(
    new Gs2.Gs2Inventory.Request.PreUpdateCurrentItemModelMasterRequest()
        .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 Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.pre_update_current_item_model_master(
        inventory.PreUpdateCurrentItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

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

client = gs2('inventory')

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

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

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

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

updateCurrentItemModelMaster

Update the currently available possession master

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
mode	enum { “direct”, “preUpload” }		✓	“direct”	~ 128 chars	Update mode
settings	string	{mode} == “direct”	✓		~ 5242880 chars	Master data If mode is “direct”, then required
uploadToken	string	{mode} == “preUpload”	✓		~ 1024 chars	Token used to reflect results after upload If mode is “preUpload”, then required

Definition of enumeration type to be specified for mode

Enumerator String Definition	Description
direct	Directly update the settings
preUpload	Upload the settings and then update

Result

	Type	Description
item	CurrentItemModelMaster	Updated and currently available possession master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentItemModelMaster(
    &inventory.UpdateCurrentItemModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Mode: nil,
        Settings: pointy.String("{\"version\": \"2019-02-05\", \"inventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"initialCapacity\": 100, \"maxCapacity\": 999, \"itemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}, {\"name\": \"character\", \"metadata\": \"INVENTORY_CHARACTER\", \"initialCapacity\": 50, \"maxCapacity\": 99, \"itemModels\": [{\"name\": \"character-0001\", \"metadata\": \"CHARACTER_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"character-0002\", \"metadata\": \"CHARACTER_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"character-0003\", \"metadata\": \"CHARACTER_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}], \"simpleInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"simpleItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}], \"bigInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"bigItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}]}"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateCurrentItemModelMasterRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentItemModelMaster(
        (new UpdateCurrentItemModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode(null)
            ->withSettings("{\"version\": \"2019-02-05\", \"inventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"initialCapacity\": 100, \"maxCapacity\": 999, \"itemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}, {\"name\": \"character\", \"metadata\": \"INVENTORY_CHARACTER\", \"initialCapacity\": 50, \"maxCapacity\": 99, \"itemModels\": [{\"name\": \"character-0001\", \"metadata\": \"CHARACTER_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"character-0002\", \"metadata\": \"CHARACTER_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"character-0003\", \"metadata\": \"CHARACTER_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}], \"simpleInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"simpleItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}], \"bigInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"bigItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}]}")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateCurrentItemModelMasterRequest;
import io.gs2.inventory.result.UpdateCurrentItemModelMasterResult;

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

try {
    UpdateCurrentItemModelMasterResult result = client.updateCurrentItemModelMaster(
        new UpdateCurrentItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode(null)
            .withSettings("{\"version\": \"2019-02-05\", \"inventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"initialCapacity\": 100, \"maxCapacity\": 999, \"itemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}, {\"name\": \"character\", \"metadata\": \"INVENTORY_CHARACTER\", \"initialCapacity\": 50, \"maxCapacity\": 99, \"itemModels\": [{\"name\": \"character-0001\", \"metadata\": \"CHARACTER_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"character-0002\", \"metadata\": \"CHARACTER_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"character-0003\", \"metadata\": \"CHARACTER_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}], \"simpleInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"simpleItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}], \"bigInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"bigItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}]}")
            .withUploadToken(null)
    );
    CurrentItemModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateCurrentItemModelMasterRequest;
using Gs2.Gs2Inventory.Result.UpdateCurrentItemModelMasterResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateCurrentItemModelMasterResult> asyncResult = null;
yield return client.UpdateCurrentItemModelMaster(
    new Gs2.Gs2Inventory.Request.UpdateCurrentItemModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode(null)
        .WithSettings("{\"version\": \"2019-02-05\", \"inventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"initialCapacity\": 100, \"maxCapacity\": 999, \"itemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}, {\"name\": \"character\", \"metadata\": \"INVENTORY_CHARACTER\", \"initialCapacity\": 50, \"maxCapacity\": 99, \"itemModels\": [{\"name\": \"character-0001\", \"metadata\": \"CHARACTER_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"character-0002\", \"metadata\": \"CHARACTER_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"character-0003\", \"metadata\": \"CHARACTER_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}], \"simpleInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"simpleItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}], \"bigInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"bigItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}]}")
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateCurrentItemModelMaster(
        new Gs2Inventory.UpdateCurrentItemModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode(null)
            .withSettings("{\"version\": \"2019-02-05\", \"inventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"initialCapacity\": 100, \"maxCapacity\": 999, \"itemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}, {\"name\": \"character\", \"metadata\": \"INVENTORY_CHARACTER\", \"initialCapacity\": 50, \"maxCapacity\": 99, \"itemModels\": [{\"name\": \"character-0001\", \"metadata\": \"CHARACTER_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"character-0002\", \"metadata\": \"CHARACTER_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"character-0003\", \"metadata\": \"CHARACTER_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}], \"simpleInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"simpleItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}], \"bigInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"bigItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}]}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.update_current_item_model_master(
        inventory.UpdateCurrentItemModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode(None)
            .with_settings('{"version": "2019-02-05", "inventoryModels": [{"name": "item", "metadata": "INVENTORY_ITEM", "initialCapacity": 100, "maxCapacity": 999, "itemModels": [{"name": "item-0001", "metadata": "ITEM_0001", "stackingLimit": 99, "allowMultipleStacks": false, "sortValue": 1}, {"name": "item-0002", "metadata": "ITEM_0002", "stackingLimit": 49, "allowMultipleStacks": true, "sortValue": 2}, {"name": "item-0003", "metadata": "ITEM_0003", "stackingLimit": 9, "allowMultipleStacks": false, "sortValue": 3}]}, {"name": "character", "metadata": "INVENTORY_CHARACTER", "initialCapacity": 50, "maxCapacity": 99, "itemModels": [{"name": "character-0001", "metadata": "CHARACTER_0001", "stackingLimit": 99, "allowMultipleStacks": false, "sortValue": 1}, {"name": "character-0002", "metadata": "CHARACTER_0002", "stackingLimit": 49, "allowMultipleStacks": true, "sortValue": 2}, {"name": "character-0003", "metadata": "CHARACTER_0003", "stackingLimit": 9, "allowMultipleStacks": false, "sortValue": 3}]}], "simpleInventoryModels": [{"name": "item", "metadata": "INVENTORY_ITEM", "simpleItemModels": [{"name": "item-0001", "metadata": "ITEM_0001"}, {"name": "item-0002", "metadata": "ITEM_0002"}, {"name": "item-0003", "metadata": "ITEM_0003"}]}], "bigInventoryModels": [{"name": "item", "metadata": "INVENTORY_ITEM", "bigItemModels": [{"name": "item-0001", "metadata": "ITEM_0001"}, {"name": "item-0002", "metadata": "ITEM_0002"}, {"name": "item-0003", "metadata": "ITEM_0003"}]}]}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.update_current_item_model_master({
    namespaceName="namespace-0001",
    mode=nil,
    settings="{\"version\": \"2019-02-05\", \"inventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"initialCapacity\": 100, \"maxCapacity\": 999, \"itemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}, {\"name\": \"character\", \"metadata\": \"INVENTORY_CHARACTER\", \"initialCapacity\": 50, \"maxCapacity\": 99, \"itemModels\": [{\"name\": \"character-0001\", \"metadata\": \"CHARACTER_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"character-0002\", \"metadata\": \"CHARACTER_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"character-0003\", \"metadata\": \"CHARACTER_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}], \"simpleInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"simpleItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}], \"bigInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"bigItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}]}",
    uploadToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.update_current_item_model_master_async({
    namespaceName="namespace-0001",
    mode=nil,
    settings="{\"version\": \"2019-02-05\", \"inventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"initialCapacity\": 100, \"maxCapacity\": 999, \"itemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}, {\"name\": \"character\", \"metadata\": \"INVENTORY_CHARACTER\", \"initialCapacity\": 50, \"maxCapacity\": 99, \"itemModels\": [{\"name\": \"character-0001\", \"metadata\": \"CHARACTER_0001\", \"stackingLimit\": 99, \"allowMultipleStacks\": false, \"sortValue\": 1}, {\"name\": \"character-0002\", \"metadata\": \"CHARACTER_0002\", \"stackingLimit\": 49, \"allowMultipleStacks\": true, \"sortValue\": 2}, {\"name\": \"character-0003\", \"metadata\": \"CHARACTER_0003\", \"stackingLimit\": 9, \"allowMultipleStacks\": false, \"sortValue\": 3}]}], \"simpleInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"simpleItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}], \"bigInventoryModels\": [{\"name\": \"item\", \"metadata\": \"INVENTORY_ITEM\", \"bigItemModels\": [{\"name\": \"item-0001\", \"metadata\": \"ITEM_0001\"}, {\"name\": \"item-0002\", \"metadata\": \"ITEM_0002\"}, {\"name\": \"item-0003\", \"metadata\": \"ITEM_0003\"}]}]}",
    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['message'])
end

result = api_result.result
item = result.item;

updateCurrentItemModelMasterFromGitHub

Update the currently available possession master

Request

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

Result

	Type	Description
item	CurrentItemModelMaster	Updated and currently available possession master

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentItemModelMasterFromGitHub(
    &inventory.UpdateCurrentItemModelMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace-0001"),
        CheckoutSetting: &inventory.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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\UpdateCurrentItemModelMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateCurrentItemModelMasterFromGitHub(
        (new UpdateCurrentItemModelMasterFromGitHubRequest())
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.UpdateCurrentItemModelMasterFromGitHubRequest;
import io.gs2.inventory.result.UpdateCurrentItemModelMasterFromGitHubResult;

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

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

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.UpdateCurrentItemModelMasterFromGitHubRequest;
using Gs2.Gs2Inventory.Result.UpdateCurrentItemModelMasterFromGitHubResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.UpdateCurrentItemModelMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentItemModelMasterFromGitHub(
    new Gs2.Gs2Inventory.Request.UpdateCurrentItemModelMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2Inventory.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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.updateCurrentItemModelMasterFromGitHub(
        new Gs2Inventory.UpdateCurrentItemModelMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2Inventory.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 inventory

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

try:
    result = client.update_current_item_model_master_from_git_hub(
        inventory.UpdateCurrentItemModelMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(inventory.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('inventory')

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

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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

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

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

result = api_result.result
item = result.item;

describeInventories

Get list of inventories

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	Access token
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<Inventory>	List of Inventories
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeInventories(
    &inventory.DescribeInventoriesRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeInventoriesRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeInventoriesRequest;
import io.gs2.inventory.result.DescribeInventoriesResult;

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

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

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeInventoriesRequest;
using Gs2.Gs2Inventory.Result.DescribeInventoriesResult;

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

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

client = gs2('inventory')

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

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

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

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

describeInventoriesByUserId

Get list of inventories by user ID

Request

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

Result

	Type	Description
items	List<Inventory>	List of Inventories
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeInventoriesByUserId(
    &inventory.DescribeInventoriesByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeInventoriesByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeInventoriesByUserIdRequest;
import io.gs2.inventory.result.DescribeInventoriesByUserIdResult;

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

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

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeInventoriesByUserIdRequest;
using Gs2.Gs2Inventory.Result.DescribeInventoriesByUserIdResult;

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

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

client = gs2('inventory')

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

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

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

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

getInventory

Get Inventory

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
accessToken	string	✓	~ 128 chars	Access token

Result

	Type	Description
item	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetInventory(
    &inventory.GetInventoryRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetInventoryRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getInventory(
        (new GetInventoryRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetInventoryRequest;
import io.gs2.inventory.result.GetInventoryResult;

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

try {
    GetInventoryResult result = client.getInventory(
        new GetInventoryRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
    );
    Inventory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetInventoryRequest;
using Gs2.Gs2Inventory.Result.GetInventoryResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetInventoryResult> asyncResult = null;
yield return client.GetInventory(
    new Gs2.Gs2Inventory.Request.GetInventoryRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getInventory(
        new Gs2Inventory.GetInventoryRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_inventory(
        inventory.GetInventoryRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_inventory({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_inventory_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
})

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

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

result = api_result.result
item = result.item;

getInventoryByUserId

Get inventory by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
userId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetInventoryByUserId(
    &inventory.GetInventoryByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetInventoryByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getInventoryByUserId(
        (new GetInventoryByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetInventoryByUserIdRequest;
import io.gs2.inventory.result.GetInventoryByUserIdResult;

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

try {
    GetInventoryByUserIdResult result = client.getInventoryByUserId(
        new GetInventoryByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    Inventory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetInventoryByUserIdRequest;
using Gs2.Gs2Inventory.Result.GetInventoryByUserIdResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetInventoryByUserIdResult> asyncResult = null;
yield return client.GetInventoryByUserId(
    new Gs2.Gs2Inventory.Request.GetInventoryByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getInventoryByUserId(
        new Gs2Inventory.GetInventoryByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_inventory_by_user_id(
        inventory.GetInventoryByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_inventory_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.get_inventory_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

addCapacityByUserId

Add inventory capacity size by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
userId	string	✓	~ 128 chars	User Id
addCapacityValue	int	✓	1 ~ 2147483646	Capacity size to be added
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	Inventory	Inventory after capacity addition

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AddCapacityByUserId(
    &inventory.AddCapacityByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        AddCapacityValue: pointy.Int32(1),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AddCapacityByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->addCapacityByUserId(
        (new AddCapacityByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withAddCapacityValue(1)
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AddCapacityByUserIdRequest;
import io.gs2.inventory.result.AddCapacityByUserIdResult;

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

try {
    AddCapacityByUserIdResult result = client.addCapacityByUserId(
        new AddCapacityByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withAddCapacityValue(1)
            .withTimeOffsetToken(null)
    );
    Inventory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AddCapacityByUserIdRequest;
using Gs2.Gs2Inventory.Result.AddCapacityByUserIdResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.AddCapacityByUserIdResult> asyncResult = null;
yield return client.AddCapacityByUserId(
    new Gs2.Gs2Inventory.Request.AddCapacityByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithAddCapacityValue(1)
        .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 Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.addCapacityByUserId(
        new Gs2Inventory.AddCapacityByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withAddCapacityValue(1)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.add_capacity_by_user_id(
        inventory.AddCapacityByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_add_capacity_value(1)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.add_capacity_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    addCapacityValue=1,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.add_capacity_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    addCapacityValue=1,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

setCapacityByUserId

Set inventory capacity size by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
userId	string	✓	~ 128 chars	User Id
newCapacityValue	int	✓	1 ~ 2147483646	New maximum capacity for inventory
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	Inventory	Inventory after update
old	Inventory	Inventory before update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.SetCapacityByUserId(
    &inventory.SetCapacityByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        NewCapacityValue: pointy.Int32(10),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\SetCapacityByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setCapacityByUserId(
        (new SetCapacityByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withNewCapacityValue(10)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $old = $result->getOld();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.SetCapacityByUserIdRequest;
import io.gs2.inventory.result.SetCapacityByUserIdResult;

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

try {
    SetCapacityByUserIdResult result = client.setCapacityByUserId(
        new SetCapacityByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withNewCapacityValue(10)
            .withTimeOffsetToken(null)
    );
    Inventory item = result.getItem();
    Inventory old = result.getOld();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.SetCapacityByUserIdRequest;
using Gs2.Gs2Inventory.Result.SetCapacityByUserIdResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.SetCapacityByUserIdResult> asyncResult = null;
yield return client.SetCapacityByUserId(
    new Gs2.Gs2Inventory.Request.SetCapacityByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithNewCapacityValue(10)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.setCapacityByUserId(
        new Gs2Inventory.SetCapacityByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withNewCapacityValue(10)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const old = result.getOld();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.set_capacity_by_user_id(
        inventory.SetCapacityByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_new_capacity_value(10)
            .with_time_offset_token(None)
    )
    item = result.item
    old = result.old
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.set_capacity_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    newCapacityValue=10,
    timeOffsetToken=nil,
})

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

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

client = gs2('inventory')

api_result_handler = client.set_capacity_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    newCapacityValue=10,
    timeOffsetToken=nil,
})

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

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

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

deleteInventoryByUserId

Delete inventory

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
userId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteInventoryByUserId(
    &inventory.DeleteInventoryByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteInventoryByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteInventoryByUserId(
        (new DeleteInventoryByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteInventoryByUserIdRequest;
import io.gs2.inventory.result.DeleteInventoryByUserIdResult;

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

try {
    DeleteInventoryByUserIdResult result = client.deleteInventoryByUserId(
        new DeleteInventoryByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    Inventory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteInventoryByUserIdRequest;
using Gs2.Gs2Inventory.Result.DeleteInventoryByUserIdResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.DeleteInventoryByUserIdResult> asyncResult = null;
yield return client.DeleteInventoryByUserId(
    new Gs2.Gs2Inventory.Request.DeleteInventoryByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.deleteInventoryByUserId(
        new Gs2Inventory.DeleteInventoryByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.delete_inventory_by_user_id(
        inventory.DeleteInventoryByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_inventory_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_inventory_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

verifyInventoryCurrentMaxCapacity

Verify current max inventory capacity

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	Access token
inventoryName	string	✓		~ 128 chars	Inventory Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
currentInventoryMaxCapacity	int	✓		~ 2147483646	Maximum capacity
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Current max inventory capacity is less than the specified value
lessEqual	Current max inventory capacity is less than or equal to the specified value
greater	Current max inventory capacity is greater than the specified value
greaterEqual	Current max inventory capacity is greater than or equal to the specified value
equal	Current max inventory capacity is equal to the specified value
notEqual	Current max inventory capacity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyInventoryCurrentMaxCapacity(
    &inventory.VerifyInventoryCurrentMaxCapacityRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        InventoryName: pointy.String("inventory-0001"),
        VerifyType: pointy.String("less"),
        CurrentInventoryMaxCapacity: pointy.Int32(10),
        MultiplyValueSpecifyingQuantity: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyInventoryCurrentMaxCapacityRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyInventoryCurrentMaxCapacity(
        (new VerifyInventoryCurrentMaxCapacityRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withInventoryName("inventory-0001")
            ->withVerifyType("less")
            ->withCurrentInventoryMaxCapacity(10)
            ->withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyInventoryCurrentMaxCapacityRequest;
import io.gs2.inventory.result.VerifyInventoryCurrentMaxCapacityResult;

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

try {
    VerifyInventoryCurrentMaxCapacityResult result = client.verifyInventoryCurrentMaxCapacity(
        new VerifyInventoryCurrentMaxCapacityRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withVerifyType("less")
            .withCurrentInventoryMaxCapacity(10)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyInventoryCurrentMaxCapacityRequest;
using Gs2.Gs2Inventory.Result.VerifyInventoryCurrentMaxCapacityResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.VerifyInventoryCurrentMaxCapacityResult> asyncResult = null;
yield return client.VerifyInventoryCurrentMaxCapacity(
    new Gs2.Gs2Inventory.Request.VerifyInventoryCurrentMaxCapacityRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithInventoryName("inventory-0001")
        .WithVerifyType("less")
        .WithCurrentInventoryMaxCapacity(10)
        .WithMultiplyValueSpecifyingQuantity(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.verifyInventoryCurrentMaxCapacity(
        new Gs2Inventory.VerifyInventoryCurrentMaxCapacityRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withVerifyType("less")
            .withCurrentInventoryMaxCapacity(10)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.verify_inventory_current_max_capacity(
        inventory.VerifyInventoryCurrentMaxCapacityRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_inventory_name('inventory-0001')
            .with_verify_type('less')
            .with_current_inventory_max_capacity(10)
            .with_multiply_value_specifying_quantity(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_inventory_current_max_capacity({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    verifyType="less",
    currentInventoryMaxCapacity=10,
    multiplyValueSpecifyingQuantity=nil,
})

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

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_inventory_current_max_capacity_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    verifyType="less",
    currentInventoryMaxCapacity=10,
    multiplyValueSpecifyingQuantity=nil,
})

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

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

result = api_result.result

verifyInventoryCurrentMaxCapacityByUserId

Verify current max inventory capacity by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
inventoryName	string	✓		~ 128 chars	Inventory Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
currentInventoryMaxCapacity	int	✓		~ 2147483646	Maximum capacity
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity
timeOffsetToken	string			~ 1024 chars	Time offset token

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Current max inventory capacity is less than the specified value
lessEqual	Current max inventory capacity is less than or equal to the specified value
greater	Current max inventory capacity is greater than the specified value
greaterEqual	Current max inventory capacity is greater than or equal to the specified value
equal	Current max inventory capacity is equal to the specified value
notEqual	Current max inventory capacity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyInventoryCurrentMaxCapacityByUserId(
    &inventory.VerifyInventoryCurrentMaxCapacityByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        InventoryName: pointy.String("inventory-0001"),
        VerifyType: pointy.String("less"),
        CurrentInventoryMaxCapacity: pointy.Int32(10),
        MultiplyValueSpecifyingQuantity: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyInventoryCurrentMaxCapacityByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyInventoryCurrentMaxCapacityByUserId(
        (new VerifyInventoryCurrentMaxCapacityByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withInventoryName("inventory-0001")
            ->withVerifyType("less")
            ->withCurrentInventoryMaxCapacity(10)
            ->withMultiplyValueSpecifyingQuantity(null)
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyInventoryCurrentMaxCapacityByUserIdRequest;
import io.gs2.inventory.result.VerifyInventoryCurrentMaxCapacityByUserIdResult;

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

try {
    VerifyInventoryCurrentMaxCapacityByUserIdResult result = client.verifyInventoryCurrentMaxCapacityByUserId(
        new VerifyInventoryCurrentMaxCapacityByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withVerifyType("less")
            .withCurrentInventoryMaxCapacity(10)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyInventoryCurrentMaxCapacityByUserIdRequest;
using Gs2.Gs2Inventory.Result.VerifyInventoryCurrentMaxCapacityByUserIdResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.VerifyInventoryCurrentMaxCapacityByUserIdResult> asyncResult = null;
yield return client.VerifyInventoryCurrentMaxCapacityByUserId(
    new Gs2.Gs2Inventory.Request.VerifyInventoryCurrentMaxCapacityByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithInventoryName("inventory-0001")
        .WithVerifyType("less")
        .WithCurrentInventoryMaxCapacity(10)
        .WithMultiplyValueSpecifyingQuantity(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.verifyInventoryCurrentMaxCapacityByUserId(
        new Gs2Inventory.VerifyInventoryCurrentMaxCapacityByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withVerifyType("less")
            .withCurrentInventoryMaxCapacity(10)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.verify_inventory_current_max_capacity_by_user_id(
        inventory.VerifyInventoryCurrentMaxCapacityByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_inventory_name('inventory-0001')
            .with_verify_type('less')
            .with_current_inventory_max_capacity(10)
            .with_multiply_value_specifying_quantity(None)
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_inventory_current_max_capacity_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    verifyType="less",
    currentInventoryMaxCapacity=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_inventory_current_max_capacity_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    verifyType="less",
    currentInventoryMaxCapacity=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result

verifyInventoryCurrentMaxCapacityByStampTask

Execute verification of current max inventory capacity as verify action

Request

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

Result

	Type	Description
newContextStack	string	Request of context in which verify action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyInventoryCurrentMaxCapacityByStampTask(
    &inventory.VerifyInventoryCurrentMaxCapacityByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyInventoryCurrentMaxCapacityByStampTaskRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyInventoryCurrentMaxCapacityByStampTask(
        (new VerifyInventoryCurrentMaxCapacityByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyInventoryCurrentMaxCapacityByStampTaskRequest;
import io.gs2.inventory.result.VerifyInventoryCurrentMaxCapacityByStampTaskResult;

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

try {
    VerifyInventoryCurrentMaxCapacityByStampTaskResult result = client.verifyInventoryCurrentMaxCapacityByStampTask(
        new VerifyInventoryCurrentMaxCapacityByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyInventoryCurrentMaxCapacityByStampTaskRequest;
using Gs2.Gs2Inventory.Result.VerifyInventoryCurrentMaxCapacityByStampTaskResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.VerifyInventoryCurrentMaxCapacityByStampTaskResult> asyncResult = null;
yield return client.VerifyInventoryCurrentMaxCapacityByStampTask(
    new Gs2.Gs2Inventory.Request.VerifyInventoryCurrentMaxCapacityByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.verifyInventoryCurrentMaxCapacityByStampTask(
        new Gs2Inventory.VerifyInventoryCurrentMaxCapacityByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.verify_inventory_current_max_capacity_by_stamp_task(
        inventory.VerifyInventoryCurrentMaxCapacityByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_inventory_current_max_capacity_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

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

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.verify_inventory_current_max_capacity_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

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

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

result = api_result.result
newContextStack = result.newContextStack;

addCapacityByStampSheet

Execute inventory capacity size addition as acquire action

Request

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

Result

	Type	Description
item	Inventory	Inventory after capacity addition

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AddCapacityByStampSheet(
    &inventory.AddCapacityByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AddCapacityByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->addCapacityByStampSheet(
        (new AddCapacityByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AddCapacityByStampSheetRequest;
import io.gs2.inventory.result.AddCapacityByStampSheetResult;

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

try {
    AddCapacityByStampSheetResult result = client.addCapacityByStampSheet(
        new AddCapacityByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    Inventory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AddCapacityByStampSheetRequest;
using Gs2.Gs2Inventory.Result.AddCapacityByStampSheetResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.AddCapacityByStampSheetResult> asyncResult = null;
yield return client.AddCapacityByStampSheet(
    new Gs2.Gs2Inventory.Request.AddCapacityByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.addCapacityByStampSheet(
        new Gs2Inventory.AddCapacityByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.add_capacity_by_stamp_sheet(
        inventory.AddCapacityByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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

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

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

result = api_result.result
item = result.item;

setCapacityByStampSheet

Execute inventory capacity size setting as acquire action

Request

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

Result

	Type	Description
item	Inventory	Inventory after update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.SetCapacityByStampSheet(
    &inventory.SetCapacityByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\SetCapacityByStampSheetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setCapacityByStampSheet(
        (new SetCapacityByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.SetCapacityByStampSheetRequest;
import io.gs2.inventory.result.SetCapacityByStampSheetResult;

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

try {
    SetCapacityByStampSheetResult result = client.setCapacityByStampSheet(
        new SetCapacityByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    Inventory item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.SetCapacityByStampSheetRequest;
using Gs2.Gs2Inventory.Result.SetCapacityByStampSheetResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.SetCapacityByStampSheetResult> asyncResult = null;
yield return client.SetCapacityByStampSheet(
    new Gs2.Gs2Inventory.Request.SetCapacityByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.setCapacityByStampSheet(
        new Gs2Inventory.SetCapacityByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.set_capacity_by_stamp_sheet(
        inventory.SetCapacityByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

result = api_result.result
item = result.item;

client = gs2('inventory')

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

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

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

result = api_result.result
item = result.item;

describeItemSets

Obtain list of item possession quantities by expiration date

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
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<ItemSet>	List of Quantity of items held per expiration date
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeItemSets(
    &inventory.DescribeItemSetsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        AccessToken: pointy.String("accessToken-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeItemSetsRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeItemSetsRequest;
import io.gs2.inventory.result.DescribeItemSetsResult;

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

try {
    DescribeItemSetsResult result = client.describeItemSets(
        new DescribeItemSetsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<ItemSet> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeItemSetsRequest;
using Gs2.Gs2Inventory.Result.DescribeItemSetsResult;

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

try:
    result = client.describe_item_sets(
        inventory.DescribeItemSetsRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_access_token('accessToken-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

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

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

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

client = gs2('inventory')

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

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

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

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

describeItemSetsByUserId

Obtain list of item possession quantities by expiration date, specifying the user ID

Request

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

Result

	Type	Description
items	List<ItemSet>	List of Quantity of items held per expiration date
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeItemSetsByUserId(
    &inventory.DescribeItemSetsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeItemSetsByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeItemSetsByUserIdRequest;
import io.gs2.inventory.result.DescribeItemSetsByUserIdResult;

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

try {
    DescribeItemSetsByUserIdResult result = client.describeItemSetsByUserId(
        new DescribeItemSetsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<ItemSet> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeItemSetsByUserIdRequest;
using Gs2.Gs2Inventory.Result.DescribeItemSetsByUserIdResult;

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

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

from gs2 import core
from gs2 import inventory

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

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

client = gs2('inventory')

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

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

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

client = gs2('inventory')

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

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

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

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

getItemSet

Get the quantity of items held by expiration date

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
accessToken	string	✓	~ 128 chars	Access token
itemName	string	✓	~ 128 chars	Item Model Name
itemSetName	string		~ 36 chars	Name identifying the item set

Result

	Type	Description
items	List<ItemSet>	List of Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetItemSet(
    &inventory.GetItemSetRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("itemSet-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetItemSetRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getItemSet(
        (new GetItemSetRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withItemSetName("itemSet-0001")
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetItemSetRequest;
import io.gs2.inventory.result.GetItemSetResult;

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

try {
    GetItemSetResult result = client.getItemSet(
        new GetItemSetRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("itemSet-0001")
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetItemSetRequest;
using Gs2.Gs2Inventory.Result.GetItemSetResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetItemSetResult> asyncResult = null;
yield return client.GetItemSet(
    new Gs2.Gs2Inventory.Request.GetItemSetRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithItemSetName("itemSet-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getItemSet(
        new Gs2Inventory.GetItemSetRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("itemSet-0001")
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_item_set(
        inventory.GetItemSetRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_item_set_name('itemSet-0001')
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_item_set({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="itemSet-0001",
})

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

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.get_item_set_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="itemSet-0001",
})

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

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

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

getItemSetByUserId

Obtain the quantity of items held by expiration date by specifying the user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Item Model Name
itemSetName	string		~ 36 chars	Name identifying the item set
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
items	List<ItemSet>	List of Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetItemSetByUserId(
    &inventory.GetItemSetByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetItemSetByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getItemSetByUserId(
        (new GetItemSetByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetItemSetByUserIdRequest;
import io.gs2.inventory.result.GetItemSetByUserIdResult;

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

try {
    GetItemSetByUserIdResult result = client.getItemSetByUserId(
        new GetItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName(null)
            .withTimeOffsetToken(null)
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetItemSetByUserIdRequest;
using Gs2.Gs2Inventory.Result.GetItemSetByUserIdResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetItemSetByUserIdResult> asyncResult = null;
yield return client.GetItemSetByUserId(
    new Gs2.Gs2Inventory.Request.GetItemSetByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getItemSetByUserId(
        new Gs2Inventory.GetItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_item_set_by_user_id(
        inventory.GetItemSetByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name(None)
            .with_time_offset_token(None)
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_item_set_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.get_item_set_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

getItemWithSignature

Get the quantity of items in your possession by expiration date along with your signature

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string			~ 36 chars	Name identifying the item set
keyId	string	✓	“grn:gs2:{region}:{ownerId}:key:default:key:default”	~ 1024 chars	encryption key GRN

Result

	Type	Description
items	List<ItemSet>	List of Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
body	string	Item Set Information for Signature Subject
signature	string	Signature

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetItemWithSignature(
    &inventory.GetItemWithSignatureRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: nil,
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory
body := result.Body
signature := result.Signature

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetItemWithSignatureRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getItemWithSignature(
        (new GetItemWithSignatureRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withItemSetName(null)
            ->withKeyId("key-0001")
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $body = $result->getBody();
    $signature = $result->getSignature();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetItemWithSignatureRequest;
import io.gs2.inventory.result.GetItemWithSignatureResult;

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

try {
    GetItemWithSignatureResult result = client.getItemWithSignature(
        new GetItemWithSignatureRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName(null)
            .withKeyId("key-0001")
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    String body = result.getBody();
    String signature = result.getSignature();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetItemWithSignatureRequest;
using Gs2.Gs2Inventory.Result.GetItemWithSignatureResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetItemWithSignatureResult> asyncResult = null;
yield return client.GetItemWithSignature(
    new Gs2.Gs2Inventory.Request.GetItemWithSignatureRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithItemSetName(null)
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var body = result.Body;
var signature = result.Signature;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

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

try {
    const result = await client.getItemWithSignature(
        new Gs2Inventory.GetItemWithSignatureRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName(null)
            .withKeyId("key-0001")
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const body = result.getBody();
    const signature = result.getSignature();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

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

try:
    result = client.get_item_with_signature(
        inventory.GetItemWithSignatureRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_item_set_name(None)
            .with_key_id('key-0001')
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
    body = result.body
    signature = result.signature
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_item_with_signature({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName=nil,
    keyId="key-0001",
})

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

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
body = result.body;
signature = result.signature;

client = gs2('inventory')

api_result_handler = client.get_item_with_signature_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName=nil,
    keyId="key-0001",
})

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

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

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
body = result.body;
signature = result.signature;

getItemWithSignatureByUserId

Obtain the quantity of items held by expiration date by specifying the user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string			~ 36 chars	Name identifying the item set
keyId	string	✓	“grn:gs2:{region}:{ownerId}:key:default:key:default”	~ 1024 chars	encryption key GRN
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<ItemSet>	List of Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
body	string	Item Set Information for Signature Subject
signature	string	Signature

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetItemWithSignatureByUserId(
    &inventory.GetItemWithSignatureByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: nil,
        KeyId: pointy.String("key-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory
body := result.Body
signature := result.Signature

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetItemWithSignatureByUserIdRequest;

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

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getItemWithSignatureByUserId(
        (new GetItemWithSignatureByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName(null)
            ->withKeyId("key-0001")
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $body = $result->getBody();
    $signature = $result->getSignature();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetItemWithSignatureByUserIdRequest;
import io.gs2.inventory.result.GetItemWithSignatureByUserIdResult;

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

try {
    GetItemWithSignatureByUserIdResult result = client.getItemWithSignatureByUserId(
        new GetItemWithSignatureByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName(null)
            .withKeyId("key-0001")
            .withTimeOffsetToken(null)
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    String body = result.getBody();
    String signature = result.getSignature();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetItemWithSignatureByUserIdRequest;
using Gs2.Gs2Inventory.Result.GetItemWithSignatureByUserIdResult;

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

AsyncResult<Gs2.Gs2Inventory.Result.GetItemWithSignatureByUserIdResult> asyncResult = null;
yield return client.GetItemWithSignatureByUserId(
    new Gs2.Gs2Inventory.Request.GetItemWithSignatureByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName(null)
        .WithKeyId("key-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var body = result.Body;
var signature = result.Signature;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getItemWithSignatureByUserId(
        new Gs2Inventory.GetItemWithSignatureByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName(null)
            .withKeyId("key-0001")
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const body = result.getBody();
    const signature = result.getSignature();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_item_with_signature_by_user_id(
        inventory.GetItemWithSignatureByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name(None)
            .with_key_id('key-0001')
            .with_time_offset_token(None)
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
    body = result.body
    signature = result.signature
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_item_with_signature_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName=nil,
    keyId="key-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
body = result.body;
signature = result.signature;

client = gs2('inventory')

api_result_handler = client.get_item_with_signature_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName=nil,
    keyId="key-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
body = result.body;
signature = result.signature;

acquireItemSetByUserId

Acquire items by specifying the user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
itemName	string	✓		~ 128 chars	Item Model Name
userId	string	✓		~ 128 chars	User Id
acquireCount	long	✓		1 ~ 9223372036854775805	Quantity to be obtained
expiresAt	long	✓	0		Effective date (Unix time unit:milliseconds)
createNewItemSet	bool	✓	false		Even if there is room in an existing ItemSet, you can create a new ItemSet
itemSetName	string			~ 36 chars	Name identifying the item set
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<ItemSet>	List of item possession quantities by expiration date after addition
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
overflowCount	long	Quantity of items transferred to GS2-Inbox that were not received beyond the possession limit

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireItemSetByUserId(
    &inventory.AcquireItemSetByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        ItemName: pointy.String("item-0001"),
        UserId: pointy.String("user-0001"),
        AcquireCount: pointy.Int64(5),
        ExpiresAt: pointy.Int64(0),
        CreateNewItemSet: nil,
        ItemSetName: pointy.String("itemSet-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory
overflowCount := result.OverflowCount

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireItemSetByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireItemSetByUserId(
        (new AcquireItemSetByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withItemName("item-0001")
            ->withUserId("user-0001")
            ->withAcquireCount(5)
            ->withExpiresAt(0)
            ->withCreateNewItemSet(null)
            ->withItemSetName("itemSet-0001")
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $overflowCount = $result->getOverflowCount();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireItemSetByUserIdRequest;
import io.gs2.inventory.result.AcquireItemSetByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireItemSetByUserIdResult result = client.acquireItemSetByUserId(
        new AcquireItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-0001")
            .withUserId("user-0001")
            .withAcquireCount(5L)
            .withExpiresAt(0L)
            .withCreateNewItemSet(null)
            .withItemSetName("itemSet-0001")
            .withTimeOffsetToken(null)
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    long overflowCount = result.getOverflowCount();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireItemSetByUserIdRequest;
using Gs2.Gs2Inventory.Result.AcquireItemSetByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireItemSetByUserIdResult> asyncResult = null;
yield return client.AcquireItemSetByUserId(
    new Gs2.Gs2Inventory.Request.AcquireItemSetByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithItemName("item-0001")
        .WithUserId("user-0001")
        .WithAcquireCount(5L)
        .WithExpiresAt(0L)
        .WithCreateNewItemSet(null)
        .WithItemSetName("itemSet-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var overflowCount = result.OverflowCount;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireItemSetByUserId(
        new Gs2Inventory.AcquireItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withItemName("item-0001")
            .withUserId("user-0001")
            .withAcquireCount(5)
            .withExpiresAt(0)
            .withCreateNewItemSet(null)
            .withItemSetName("itemSet-0001")
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const overflowCount = result.getOverflowCount();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_item_set_by_user_id(
        inventory.AcquireItemSetByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_item_name('item-0001')
            .with_user_id('user-0001')
            .with_acquire_count(5)
            .with_expires_at(0)
            .with_create_new_item_set(None)
            .with_item_set_name('itemSet-0001')
            .with_time_offset_token(None)
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
    overflow_count = result.overflow_count
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_item_set_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-0001",
    userId="user-0001",
    acquireCount=5,
    expiresAt=0,
    createNewItemSet=nil,
    itemSetName="itemSet-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

client = gs2('inventory')

api_result_handler = client.acquire_item_set_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    itemName="item-0001",
    userId="user-0001",
    acquireCount=5,
    expiresAt=0,
    createNewItemSet=nil,
    itemSetName="itemSet-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

acquireItemSetWithGradeByUserId

Acquire items by specifying the user ID and setting the grade in GS2-Grade

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
itemName	string	✓	~ 128 chars	Item Model Name
userId	string	✓	~ 128 chars	User Id
gradeModelId	string	✓	~ 1024 chars	Grade Model GRN
gradeValue	long	✓	1 ~ 9223372036854775805	Grade value to set
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	ItemSet	Quantity of items held per expiration date after addition
status	Status	Grade status set
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
overflowCount	long	Quantity of items transferred to GS2-Inbox that were not received beyond the possession limit

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireItemSetWithGradeByUserId(
    &inventory.AcquireItemSetWithGradeByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        ItemName: pointy.String("item-0001"),
        UserId: pointy.String("user-0001"),
        GradeModelId: pointy.String("grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001"),
        GradeValue: pointy.Int64(1),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
status := result.Status
itemModel := result.ItemModel
inventory := result.Inventory
overflowCount := result.OverflowCount

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireItemSetWithGradeByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireItemSetWithGradeByUserId(
        (new AcquireItemSetWithGradeByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withItemName("item-0001")
            ->withUserId("user-0001")
            ->withGradeModelId("grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001")
            ->withGradeValue(1)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $status = $result->getStatus();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $overflowCount = $result->getOverflowCount();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireItemSetWithGradeByUserIdRequest;
import io.gs2.inventory.result.AcquireItemSetWithGradeByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireItemSetWithGradeByUserIdResult result = client.acquireItemSetWithGradeByUserId(
        new AcquireItemSetWithGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withUserId("user-0001")
            .withGradeModelId("grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001")
            .withGradeValue(1L)
            .withTimeOffsetToken(null)
    );
    ItemSet item = result.getItem();
    Status status = result.getStatus();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    long overflowCount = result.getOverflowCount();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireItemSetWithGradeByUserIdRequest;
using Gs2.Gs2Inventory.Result.AcquireItemSetWithGradeByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireItemSetWithGradeByUserIdResult> asyncResult = null;
yield return client.AcquireItemSetWithGradeByUserId(
    new Gs2.Gs2Inventory.Request.AcquireItemSetWithGradeByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithItemName("item-0001")
        .WithUserId("user-0001")
        .WithGradeModelId("grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001")
        .WithGradeValue(1L)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var status = result.Status;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var overflowCount = result.OverflowCount;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireItemSetWithGradeByUserId(
        new Gs2Inventory.AcquireItemSetWithGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withUserId("user-0001")
            .withGradeModelId("grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001")
            .withGradeValue(1)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const status = result.getStatus();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const overflowCount = result.getOverflowCount();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_item_set_with_grade_by_user_id(
        inventory.AcquireItemSetWithGradeByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_item_name('item-0001')
            .with_user_id('user-0001')
            .with_grade_model_id('grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001')
            .with_grade_value(1)
            .with_time_offset_token(None)
    )
    item = result.item
    status = result.status
    item_model = result.item_model
    inventory = result.inventory
    overflow_count = result.overflow_count
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_item_set_with_grade_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    userId="user-0001",
    gradeModelId="grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001",
    gradeValue=1,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
status = result.status;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

client = gs2('inventory')

api_result_handler = client.acquire_item_set_with_grade_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    userId="user-0001",
    gradeModelId="grn:ap-northeast-1:YourOwnerId:grade:namespace-0001:model:grade-0001",
    gradeValue=1,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
status = result.status;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

consumeItemSet

Consume items

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
accessToken	string	✓	~ 128 chars	Access token
itemName	string	✓	~ 128 chars	Item Model Name
consumeCount	long	✓	1 ~ 9223372036854775805	Amount to consume
itemSetName	string		~ 36 chars	Name identifying the item set

Result

	Type	Description
items	List<ItemSet>	List of item possession quantities per post-consumption expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeItemSet(
    &inventory.ConsumeItemSetRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ConsumeCount: pointy.Int64(1),
        ItemSetName: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeItemSetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeItemSet(
        (new ConsumeItemSetRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withConsumeCount(1)
            ->withItemSetName(null)
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeItemSetRequest;
import io.gs2.inventory.result.ConsumeItemSetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeItemSetResult result = client.consumeItemSet(
        new ConsumeItemSetRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withConsumeCount(1L)
            .withItemSetName(null)
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeItemSetRequest;
using Gs2.Gs2Inventory.Result.ConsumeItemSetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeItemSetResult> asyncResult = null;
yield return client.ConsumeItemSet(
    new Gs2.Gs2Inventory.Request.ConsumeItemSetRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithConsumeCount(1L)
        .WithItemSetName(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeItemSet(
        new Gs2Inventory.ConsumeItemSetRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withConsumeCount(1)
            .withItemSetName(null)
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_item_set(
        inventory.ConsumeItemSetRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_consume_count(1)
            .with_item_set_name(None)
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_item_set({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    consumeCount=1,
    itemSetName=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.consume_item_set_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    consumeCount=1,
    itemSetName=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

consumeItemSetByUserId

Consume items by specifying the user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Item Model Name
consumeCount	long	✓	1 ~ 9223372036854775805	Amount to consume
itemSetName	string		~ 36 chars	Name identifying the item set
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
items	List<ItemSet>	List of item possession quantities per post-consumption expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeItemSetByUserId(
    &inventory.ConsumeItemSetByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ConsumeCount: pointy.Int64(1),
        ItemSetName: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeItemSetByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeItemSetByUserId(
        (new ConsumeItemSetByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withConsumeCount(1)
            ->withItemSetName(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeItemSetByUserIdRequest;
import io.gs2.inventory.result.ConsumeItemSetByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeItemSetByUserIdResult result = client.consumeItemSetByUserId(
        new ConsumeItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withConsumeCount(1L)
            .withItemSetName(null)
            .withTimeOffsetToken(null)
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeItemSetByUserIdRequest;
using Gs2.Gs2Inventory.Result.ConsumeItemSetByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeItemSetByUserIdResult> asyncResult = null;
yield return client.ConsumeItemSetByUserId(
    new Gs2.Gs2Inventory.Request.ConsumeItemSetByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithConsumeCount(1L)
        .WithItemSetName(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeItemSetByUserId(
        new Gs2Inventory.ConsumeItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withConsumeCount(1)
            .withItemSetName(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_item_set_by_user_id(
        inventory.ConsumeItemSetByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_consume_count(1)
            .with_item_set_name(None)
            .with_time_offset_token(None)
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_item_set_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    consumeCount=1,
    itemSetName=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.consume_item_set_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    consumeCount=1,
    itemSetName=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

deleteItemSetByUserId

Delete item possession quantities per expiration date

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Item Model Name
itemSetName	string		~ 36 chars	Name identifying the item set
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
items	List<ItemSet>	List of item possession quantities by expiration date deleted
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteItemSetByUserId(
    &inventory.DeleteItemSetByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("itemSet-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteItemSetByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteItemSetByUserId(
        (new DeleteItemSetByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName("itemSet-0001")
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteItemSetByUserIdRequest;
import io.gs2.inventory.result.DeleteItemSetByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DeleteItemSetByUserIdResult result = client.deleteItemSetByUserId(
        new DeleteItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("itemSet-0001")
            .withTimeOffsetToken(null)
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteItemSetByUserIdRequest;
using Gs2.Gs2Inventory.Result.DeleteItemSetByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DeleteItemSetByUserIdResult> asyncResult = null;
yield return client.DeleteItemSetByUserId(
    new Gs2.Gs2Inventory.Request.DeleteItemSetByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName("itemSet-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.deleteItemSetByUserId(
        new Gs2Inventory.DeleteItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("itemSet-0001")
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.delete_item_set_by_user_id(
        inventory.DeleteItemSetByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name('itemSet-0001')
            .with_time_offset_token(None)
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_item_set_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="itemSet-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.delete_item_set_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="itemSet-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;

verifyItemSet

Verify possession quantity

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	Access token
inventoryName	string	✓		~ 128 chars	Inventory Model Name
itemName	string	✓		~ 128 chars	Item Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
itemSetName	string			~ 36 chars	Name identifying the item set
count	long	✓		~ 9223372036854775805	Quantity in possession
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Possession quantity is less than the specified value
lessEqual	Possession quantity is less than or equal to the specified value
greater	Possession quantity is greater than the specified value
greaterEqual	Possession quantity is greater than or equal to the specified value
equal	Possession quantity is equal to the specified value
notEqual	Possession quantity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyItemSet(
    &inventory.VerifyItemSetRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        InventoryName: pointy.String("inventory-0001"),
        ItemName: pointy.String("item-0001"),
        VerifyType: pointy.String("less"),
        ItemSetName: nil,
        Count: pointy.Int64(10),
        MultiplyValueSpecifyingQuantity: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyItemSetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyItemSet(
        (new VerifyItemSetRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withInventoryName("inventory-0001")
            ->withItemName("item-0001")
            ->withVerifyType("less")
            ->withItemSetName(null)
            ->withCount(10)
            ->withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyItemSetRequest;
import io.gs2.inventory.result.VerifyItemSetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyItemSetResult result = client.verifyItemSet(
        new VerifyItemSetRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withItemSetName(null)
            .withCount(10L)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyItemSetRequest;
using Gs2.Gs2Inventory.Result.VerifyItemSetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyItemSetResult> asyncResult = null;
yield return client.VerifyItemSet(
    new Gs2.Gs2Inventory.Request.VerifyItemSetRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithInventoryName("inventory-0001")
        .WithItemName("item-0001")
        .WithVerifyType("less")
        .WithItemSetName(null)
        .WithCount(10L)
        .WithMultiplyValueSpecifyingQuantity(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyItemSet(
        new Gs2Inventory.VerifyItemSetRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withItemSetName(null)
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_item_set(
        inventory.VerifyItemSetRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_inventory_name('inventory-0001')
            .with_item_name('item-0001')
            .with_verify_type('less')
            .with_item_set_name(None)
            .with_count(10)
            .with_multiply_value_specifying_quantity(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_item_set({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    itemSetName=nil,
    count=10,
    multiplyValueSpecifyingQuantity=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_item_set_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    itemSetName=nil,
    count=10,
    multiplyValueSpecifyingQuantity=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

verifyItemSetByUserId

Verify possession quantity by specifying the user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
inventoryName	string	✓		~ 128 chars	Inventory Model Name
itemName	string	✓		~ 128 chars	Item Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
itemSetName	string			~ 36 chars	Name identifying the item set
count	long	✓		~ 9223372036854775805	Quantity in possession
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity
timeOffsetToken	string			~ 1024 chars	Time offset token

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Possession quantity is less than the specified value
lessEqual	Possession quantity is less than or equal to the specified value
greater	Possession quantity is greater than the specified value
greaterEqual	Possession quantity is greater than or equal to the specified value
equal	Possession quantity is equal to the specified value
notEqual	Possession quantity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyItemSetByUserId(
    &inventory.VerifyItemSetByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        InventoryName: pointy.String("inventory-0001"),
        ItemName: pointy.String("item-0001"),
        VerifyType: pointy.String("less"),
        ItemSetName: nil,
        Count: pointy.Int64(10),
        MultiplyValueSpecifyingQuantity: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyItemSetByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyItemSetByUserId(
        (new VerifyItemSetByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withInventoryName("inventory-0001")
            ->withItemName("item-0001")
            ->withVerifyType("less")
            ->withItemSetName(null)
            ->withCount(10)
            ->withMultiplyValueSpecifyingQuantity(null)
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyItemSetByUserIdRequest;
import io.gs2.inventory.result.VerifyItemSetByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyItemSetByUserIdResult result = client.verifyItemSetByUserId(
        new VerifyItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withItemSetName(null)
            .withCount(10L)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyItemSetByUserIdRequest;
using Gs2.Gs2Inventory.Result.VerifyItemSetByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyItemSetByUserIdResult> asyncResult = null;
yield return client.VerifyItemSetByUserId(
    new Gs2.Gs2Inventory.Request.VerifyItemSetByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithInventoryName("inventory-0001")
        .WithItemName("item-0001")
        .WithVerifyType("less")
        .WithItemSetName(null)
        .WithCount(10L)
        .WithMultiplyValueSpecifyingQuantity(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyItemSetByUserId(
        new Gs2Inventory.VerifyItemSetByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withItemSetName(null)
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_item_set_by_user_id(
        inventory.VerifyItemSetByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_inventory_name('inventory-0001')
            .with_item_name('item-0001')
            .with_verify_type('less')
            .with_item_set_name(None)
            .with_count(10)
            .with_multiply_value_specifying_quantity(None)
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_item_set_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    itemSetName=nil,
    count=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_item_set_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    itemSetName=nil,
    count=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

acquireItemSetByStampSheet

Execute item acquisition as an acquire action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
items	List<ItemSet>	List of Quantity of items held per expiration date after addition
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
overflowCount	long	Quantity of items transferred to GS2-Inbox that were not received beyond the possession limit

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireItemSetByStampSheet(
    &inventory.AcquireItemSetByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory
overflowCount := result.OverflowCount

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireItemSetByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireItemSetByStampSheet(
        (new AcquireItemSetByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $overflowCount = $result->getOverflowCount();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireItemSetByStampSheetRequest;
import io.gs2.inventory.result.AcquireItemSetByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireItemSetByStampSheetResult result = client.acquireItemSetByStampSheet(
        new AcquireItemSetByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    long overflowCount = result.getOverflowCount();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireItemSetByStampSheetRequest;
using Gs2.Gs2Inventory.Result.AcquireItemSetByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireItemSetByStampSheetResult> asyncResult = null;
yield return client.AcquireItemSetByStampSheet(
    new Gs2.Gs2Inventory.Request.AcquireItemSetByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var overflowCount = result.OverflowCount;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireItemSetByStampSheet(
        new Gs2Inventory.AcquireItemSetByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const overflowCount = result.getOverflowCount();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_item_set_by_stamp_sheet(
        inventory.AcquireItemSetByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
    overflow_count = result.overflow_count
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_item_set_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

client = gs2('inventory')

api_result_handler = client.acquire_item_set_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

acquireItemSetWithGradeByStampSheet

Execute item acquisition as an acquire action while setting the grade to GS2-Grade

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	ItemSet	Quantity of items held per expiration date after addition
status	Status	Grade status set
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
overflowCount	long	Quantity of items transferred to GS2-Inbox that were not received beyond the possession limit

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireItemSetWithGradeByStampSheet(
    &inventory.AcquireItemSetWithGradeByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
status := result.Status
itemModel := result.ItemModel
inventory := result.Inventory
overflowCount := result.OverflowCount

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireItemSetWithGradeByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireItemSetWithGradeByStampSheet(
        (new AcquireItemSetWithGradeByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $status = $result->getStatus();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $overflowCount = $result->getOverflowCount();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireItemSetWithGradeByStampSheetRequest;
import io.gs2.inventory.result.AcquireItemSetWithGradeByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireItemSetWithGradeByStampSheetResult result = client.acquireItemSetWithGradeByStampSheet(
        new AcquireItemSetWithGradeByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    ItemSet item = result.getItem();
    Status status = result.getStatus();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    long overflowCount = result.getOverflowCount();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireItemSetWithGradeByStampSheetRequest;
using Gs2.Gs2Inventory.Result.AcquireItemSetWithGradeByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireItemSetWithGradeByStampSheetResult> asyncResult = null;
yield return client.AcquireItemSetWithGradeByStampSheet(
    new Gs2.Gs2Inventory.Request.AcquireItemSetWithGradeByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var status = result.Status;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var overflowCount = result.OverflowCount;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireItemSetWithGradeByStampSheet(
        new Gs2Inventory.AcquireItemSetWithGradeByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const status = result.getStatus();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const overflowCount = result.getOverflowCount();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_item_set_with_grade_by_stamp_sheet(
        inventory.AcquireItemSetWithGradeByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
    status = result.status
    item_model = result.item_model
    inventory = result.inventory
    overflow_count = result.overflow_count
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_item_set_with_grade_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
status = result.status;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

client = gs2('inventory')

api_result_handler = client.acquire_item_set_with_grade_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
status = result.status;
itemModel = result.itemModel;
inventory = result.inventory;
overflowCount = result.overflowCount;

consumeItemSetByStampTask

Execute item consumption as a consume action

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Consume Action
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
items	List<ItemSet>	List of Quantity of items held per post-consumption expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
newContextStack	string	Request of context in which consume action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeItemSetByStampTask(
    &inventory.ConsumeItemSetByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemModel := result.ItemModel
inventory := result.Inventory
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeItemSetByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeItemSetByStampTask(
        (new ConsumeItemSetByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $items = $result->getItems();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeItemSetByStampTaskRequest;
import io.gs2.inventory.result.ConsumeItemSetByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeItemSetByStampTaskResult result = client.consumeItemSetByStampTask(
        new ConsumeItemSetByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    List<ItemSet> items = result.getItems();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeItemSetByStampTaskRequest;
using Gs2.Gs2Inventory.Result.ConsumeItemSetByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeItemSetByStampTaskResult> asyncResult = null;
yield return client.ConsumeItemSetByStampTask(
    new Gs2.Gs2Inventory.Request.ConsumeItemSetByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeItemSetByStampTask(
        new Gs2Inventory.ConsumeItemSetByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const items = result.getItems();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_item_set_by_stamp_task(
        inventory.ConsumeItemSetByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    items = result.items
    item_model = result.item_model
    inventory = result.inventory
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_item_set_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.consume_item_set_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemModel = result.itemModel;
inventory = result.inventory;
newContextStack = result.newContextStack;

verifyItemSetByStampTask

Execute item possession quantity verification as a verify action

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Verify Action
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
newContextStack	string	Request of context in which verify action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyItemSetByStampTask(
    &inventory.VerifyItemSetByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyItemSetByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyItemSetByStampTask(
        (new VerifyItemSetByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyItemSetByStampTaskRequest;
import io.gs2.inventory.result.VerifyItemSetByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyItemSetByStampTaskResult result = client.verifyItemSetByStampTask(
        new VerifyItemSetByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyItemSetByStampTaskRequest;
using Gs2.Gs2Inventory.Result.VerifyItemSetByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyItemSetByStampTaskResult> asyncResult = null;
yield return client.VerifyItemSetByStampTask(
    new Gs2.Gs2Inventory.Request.VerifyItemSetByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyItemSetByStampTask(
        new Gs2Inventory.VerifyItemSetByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_item_set_by_stamp_task(
        inventory.VerifyItemSetByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_item_set_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.verify_item_set_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;

describeReferenceOf

Get list of references

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set

Result

	Type	Description
items	List<string>	List of References for this possession
itemSet	ItemSet	Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeReferenceOf(
    &inventory.DescribeReferenceOfRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeReferenceOfRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeReferenceOf(
        (new DescribeReferenceOfRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
    );
    $items = $result->getItems();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeReferenceOfRequest;
import io.gs2.inventory.result.DescribeReferenceOfResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DescribeReferenceOfResult result = client.describeReferenceOf(
        new DescribeReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
    );
    List<String> items = result.getItems();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeReferenceOfRequest;
using Gs2.Gs2Inventory.Result.DescribeReferenceOfResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DescribeReferenceOfResult> asyncResult = null;
yield return client.DescribeReferenceOf(
    new Gs2.Gs2Inventory.Request.DescribeReferenceOfRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.describeReferenceOf(
        new Gs2Inventory.DescribeReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
    );
    const items = result.getItems();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.describe_reference_of(
        inventory.DescribeReferenceOfRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
    )
    items = result.items
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_reference_of({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.describe_reference_of_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

describeReferenceOfByUserId

Obtain list of references by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<string>	List of References for this possession
itemSet	ItemSet	Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeReferenceOfByUserId(
    &inventory.DescribeReferenceOfByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeReferenceOfByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeReferenceOfByUserId(
        (new DescribeReferenceOfByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeReferenceOfByUserIdRequest;
import io.gs2.inventory.result.DescribeReferenceOfByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DescribeReferenceOfByUserIdResult result = client.describeReferenceOfByUserId(
        new DescribeReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withTimeOffsetToken(null)
    );
    List<String> items = result.getItems();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeReferenceOfByUserIdRequest;
using Gs2.Gs2Inventory.Result.DescribeReferenceOfByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DescribeReferenceOfByUserIdResult> asyncResult = null;
yield return client.DescribeReferenceOfByUserId(
    new Gs2.Gs2Inventory.Request.DescribeReferenceOfByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.describeReferenceOfByUserId(
        new Gs2Inventory.DescribeReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.describe_reference_of_by_user_id(
        inventory.DescribeReferenceOfByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_time_offset_token(None)
    )
    items = result.items
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_reference_of_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.describe_reference_of_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

getReferenceOf

Obtain a Reference

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetReferenceOf(
    &inventory.GetReferenceOfRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: ['resource-0001'],
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetReferenceOfRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getReferenceOf(
        (new GetReferenceOfRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf(['resource-0001'])
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetReferenceOfRequest;
import io.gs2.inventory.result.GetReferenceOfResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetReferenceOfResult result = client.getReferenceOf(
        new GetReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetReferenceOfRequest;
using Gs2.Gs2Inventory.Result.GetReferenceOfResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetReferenceOfResult> asyncResult = null;
yield return client.GetReferenceOf(
    new Gs2.Gs2Inventory.Request.GetReferenceOfRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf(['resource-0001']),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getReferenceOf(
        new Gs2Inventory.GetReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_reference_of(
        inventory.GetReferenceOfRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of(['resource-0001'])
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_reference_of({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.get_reference_of_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

getReferenceOfByUserId

Obtain a reference by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetReferenceOfByUserId(
    &inventory.GetReferenceOfByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: ['resource-0001'],
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetReferenceOfByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getReferenceOfByUserId(
        (new GetReferenceOfByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf(['resource-0001'])
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetReferenceOfByUserIdRequest;
import io.gs2.inventory.result.GetReferenceOfByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetReferenceOfByUserIdResult result = client.getReferenceOfByUserId(
        new GetReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
            .withTimeOffsetToken(null)
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetReferenceOfByUserIdRequest;
using Gs2.Gs2Inventory.Result.GetReferenceOfByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetReferenceOfByUserIdResult> asyncResult = null;
yield return client.GetReferenceOfByUserId(
    new Gs2.Gs2Inventory.Request.GetReferenceOfByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf(['resource-0001'])
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getReferenceOfByUserId(
        new Gs2Inventory.GetReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_reference_of_by_user_id(
        inventory.GetReferenceOfByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of(['resource-0001'])
            .with_time_offset_token(None)
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_reference_of_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.get_reference_of_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

verifyReferenceOf

Verify the reference source

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession
verifyType	enum { “not_entry”, “already_entry”, “empty”, “not_empty” }	✓		~ 128 chars	Type of verification

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
not_entry	That the specified referent is not yet registered.
already_entry	The specified reference must already be registered.
empty	Zero elements registered as referents.
not_empty	At least one element registered as a reference source

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyReferenceOf(
    &inventory.VerifyReferenceOfRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: pointy.String("resource-0001"),
        VerifyType: pointy.String("not_entry"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyReferenceOfRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyReferenceOf(
        (new VerifyReferenceOfRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf("resource-0001")
            ->withVerifyType("not_entry")
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyReferenceOfRequest;
import io.gs2.inventory.result.VerifyReferenceOfResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyReferenceOfResult result = client.verifyReferenceOf(
        new VerifyReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
            .withVerifyType("not_entry")
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyReferenceOfRequest;
using Gs2.Gs2Inventory.Result.VerifyReferenceOfResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyReferenceOfResult> asyncResult = null;
yield return client.VerifyReferenceOf(
    new Gs2.Gs2Inventory.Request.VerifyReferenceOfRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf("resource-0001")
        .WithVerifyType("not_entry"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyReferenceOf(
        new Gs2Inventory.VerifyReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
            .withVerifyType("not_entry")
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_reference_of(
        inventory.VerifyReferenceOfRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of('resource-0001')
            .with_verify_type('not_entry')
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_reference_of({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
    verifyType="not_entry",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.verify_reference_of_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
    verifyType="not_entry",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

verifyReferenceOfByUserId

Verify the reference source by specifying the user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession
verifyType	enum { “not_entry”, “already_entry”, “empty”, “not_empty” }	✓		~ 128 chars	Type of verification
timeOffsetToken	string			~ 1024 chars	Time offset token

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
not_entry	That the specified referent is not yet registered.
already_entry	The specified reference must already be registered.
empty	Zero elements registered as referents.
not_empty	At least one element registered as a reference source

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyReferenceOfByUserId(
    &inventory.VerifyReferenceOfByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: pointy.String("resource-0001"),
        VerifyType: pointy.String("not_entry"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyReferenceOfByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyReferenceOfByUserId(
        (new VerifyReferenceOfByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf("resource-0001")
            ->withVerifyType("not_entry")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyReferenceOfByUserIdRequest;
import io.gs2.inventory.result.VerifyReferenceOfByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyReferenceOfByUserIdResult result = client.verifyReferenceOfByUserId(
        new VerifyReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
            .withVerifyType("not_entry")
            .withTimeOffsetToken(null)
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyReferenceOfByUserIdRequest;
using Gs2.Gs2Inventory.Result.VerifyReferenceOfByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyReferenceOfByUserIdResult> asyncResult = null;
yield return client.VerifyReferenceOfByUserId(
    new Gs2.Gs2Inventory.Request.VerifyReferenceOfByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf("resource-0001")
        .WithVerifyType("not_entry")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyReferenceOfByUserId(
        new Gs2Inventory.VerifyReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
            .withVerifyType("not_entry")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_reference_of_by_user_id(
        inventory.VerifyReferenceOfByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of('resource-0001')
            .with_verify_type('not_entry')
            .with_time_offset_token(None)
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_reference_of_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
    verifyType="not_entry",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.verify_reference_of_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
    verifyType="not_entry",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

addReferenceOf

Add a reference

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held by expiration date after addition of reference source
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AddReferenceOf(
    &inventory.AddReferenceOfRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: ['resource-0001'],
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AddReferenceOfRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->addReferenceOf(
        (new AddReferenceOfRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf(['resource-0001'])
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AddReferenceOfRequest;
import io.gs2.inventory.result.AddReferenceOfResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AddReferenceOfResult result = client.addReferenceOf(
        new AddReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AddReferenceOfRequest;
using Gs2.Gs2Inventory.Result.AddReferenceOfResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AddReferenceOfResult> asyncResult = null;
yield return client.AddReferenceOf(
    new Gs2.Gs2Inventory.Request.AddReferenceOfRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf(['resource-0001']),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.addReferenceOf(
        new Gs2Inventory.AddReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.add_reference_of(
        inventory.AddReferenceOfRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of(['resource-0001'])
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.add_reference_of({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.add_reference_of_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

addReferenceOfByUserId

Add a reference by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held by expiration date after addition of reference source
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AddReferenceOfByUserId(
    &inventory.AddReferenceOfByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: ['resource-0001'],
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AddReferenceOfByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->addReferenceOfByUserId(
        (new AddReferenceOfByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf(['resource-0001'])
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AddReferenceOfByUserIdRequest;
import io.gs2.inventory.result.AddReferenceOfByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AddReferenceOfByUserIdResult result = client.addReferenceOfByUserId(
        new AddReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
            .withTimeOffsetToken(null)
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AddReferenceOfByUserIdRequest;
using Gs2.Gs2Inventory.Result.AddReferenceOfByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AddReferenceOfByUserIdResult> asyncResult = null;
yield return client.AddReferenceOfByUserId(
    new Gs2.Gs2Inventory.Request.AddReferenceOfByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf(['resource-0001'])
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.addReferenceOfByUserId(
        new Gs2Inventory.AddReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf(['resource-0001'])
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.add_reference_of_by_user_id(
        inventory.AddReferenceOfByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of(['resource-0001'])
            .with_time_offset_token(None)
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.add_reference_of_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.add_reference_of_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf=['resource-0001'],
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

deleteReferenceOf

Delete References

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date after deleting the reference source
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteReferenceOf(
    &inventory.DeleteReferenceOfRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: pointy.String("resource-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteReferenceOfRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteReferenceOf(
        (new DeleteReferenceOfRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf("resource-0001")
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteReferenceOfRequest;
import io.gs2.inventory.result.DeleteReferenceOfResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DeleteReferenceOfResult result = client.deleteReferenceOf(
        new DeleteReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteReferenceOfRequest;
using Gs2.Gs2Inventory.Result.DeleteReferenceOfResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DeleteReferenceOfResult> asyncResult = null;
yield return client.DeleteReferenceOf(
    new Gs2.Gs2Inventory.Request.DeleteReferenceOfRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf("resource-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.deleteReferenceOf(
        new Gs2Inventory.DeleteReferenceOfRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.delete_reference_of(
        inventory.DeleteReferenceOfRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of('resource-0001')
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_reference_of({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.delete_reference_of_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

deleteReferenceOfByUserId

Delete the reference source by specifying the user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Item Model Name
itemSetName	string	✓	UUID	~ 36 chars	Name identifying the item set
referenceOf	string	✓		~ 1024 chars	References for this possession
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date after deleting the reference source
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteReferenceOfByUserId(
    &inventory.DeleteReferenceOfByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ItemSetName: pointy.String("item-set-0001"),
        ReferenceOf: pointy.String("resource-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteReferenceOfByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteReferenceOfByUserId(
        (new DeleteReferenceOfByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withItemSetName("item-set-0001")
            ->withReferenceOf("resource-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteReferenceOfByUserIdRequest;
import io.gs2.inventory.result.DeleteReferenceOfByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DeleteReferenceOfByUserIdResult result = client.deleteReferenceOfByUserId(
        new DeleteReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
            .withTimeOffsetToken(null)
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteReferenceOfByUserIdRequest;
using Gs2.Gs2Inventory.Result.DeleteReferenceOfByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DeleteReferenceOfByUserIdResult> asyncResult = null;
yield return client.DeleteReferenceOfByUserId(
    new Gs2.Gs2Inventory.Request.DeleteReferenceOfByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithItemSetName("item-set-0001")
        .WithReferenceOf("resource-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.deleteReferenceOfByUserId(
        new Gs2Inventory.DeleteReferenceOfByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withItemSetName("item-set-0001")
            .withReferenceOf("resource-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.delete_reference_of_by_user_id(
        inventory.DeleteReferenceOfByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_item_set_name('item-set-0001')
            .with_reference_of('resource-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_reference_of_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.delete_reference_of_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    itemSetName="item-set-0001",
    referenceOf="resource-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

addReferenceOfItemSetByStampSheet

Execute addition of reference source as acquire action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held by expiration date after addition of reference source
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AddReferenceOfItemSetByStampSheet(
    &inventory.AddReferenceOfItemSetByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AddReferenceOfItemSetByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->addReferenceOfItemSetByStampSheet(
        (new AddReferenceOfItemSetByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AddReferenceOfItemSetByStampSheetRequest;
import io.gs2.inventory.result.AddReferenceOfItemSetByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AddReferenceOfItemSetByStampSheetResult result = client.addReferenceOfItemSetByStampSheet(
        new AddReferenceOfItemSetByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AddReferenceOfItemSetByStampSheetRequest;
using Gs2.Gs2Inventory.Result.AddReferenceOfItemSetByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AddReferenceOfItemSetByStampSheetResult> asyncResult = null;
yield return client.AddReferenceOfItemSetByStampSheet(
    new Gs2.Gs2Inventory.Request.AddReferenceOfItemSetByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.addReferenceOfItemSetByStampSheet(
        new Gs2Inventory.AddReferenceOfItemSetByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.add_reference_of_item_set_by_stamp_sheet(
        inventory.AddReferenceOfItemSetByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.add_reference_of_item_set_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.add_reference_of_item_set_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

deleteReferenceOfItemSetByStampSheet

Execute deletion of reference source as acquire action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date after deleting the reference source
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteReferenceOfItemSetByStampSheet(
    &inventory.DeleteReferenceOfItemSetByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteReferenceOfItemSetByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteReferenceOfItemSetByStampSheet(
        (new DeleteReferenceOfItemSetByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteReferenceOfItemSetByStampSheetRequest;
import io.gs2.inventory.result.DeleteReferenceOfItemSetByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DeleteReferenceOfItemSetByStampSheetResult result = client.deleteReferenceOfItemSetByStampSheet(
        new DeleteReferenceOfItemSetByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteReferenceOfItemSetByStampSheetRequest;
using Gs2.Gs2Inventory.Result.DeleteReferenceOfItemSetByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DeleteReferenceOfItemSetByStampSheetResult> asyncResult = null;
yield return client.DeleteReferenceOfItemSetByStampSheet(
    new Gs2.Gs2Inventory.Request.DeleteReferenceOfItemSetByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.deleteReferenceOfItemSetByStampSheet(
        new Gs2Inventory.DeleteReferenceOfItemSetByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.delete_reference_of_item_set_by_stamp_sheet(
        inventory.DeleteReferenceOfItemSetByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_reference_of_item_set_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

client = gs2('inventory')

api_result_handler = client.delete_reference_of_item_set_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;

verifyReferenceOfByStampTask

Execute verification of reference source as verify action

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Verify Action
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	string	References for this possession
itemSet	ItemSet	Quantity of items held per expiration date
itemModel	ItemModel	Item Model
inventory	Inventory	Inventory
newContextStack	string	Request of context in which verify action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyReferenceOfByStampTask(
    &inventory.VerifyReferenceOfByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemSet := result.ItemSet
itemModel := result.ItemModel
inventory := result.Inventory
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyReferenceOfByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyReferenceOfByStampTask(
        (new VerifyReferenceOfByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $itemSet = $result->getItemSet();
    $itemModel = $result->getItemModel();
    $inventory = $result->getInventory();
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyReferenceOfByStampTaskRequest;
import io.gs2.inventory.result.VerifyReferenceOfByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyReferenceOfByStampTaskResult result = client.verifyReferenceOfByStampTask(
        new VerifyReferenceOfByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String item = result.getItem();
    ItemSet itemSet = result.getItemSet();
    ItemModel itemModel = result.getItemModel();
    Inventory inventory = result.getInventory();
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyReferenceOfByStampTaskRequest;
using Gs2.Gs2Inventory.Result.VerifyReferenceOfByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyReferenceOfByStampTaskResult> asyncResult = null;
yield return client.VerifyReferenceOfByStampTask(
    new Gs2.Gs2Inventory.Request.VerifyReferenceOfByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemSet = result.ItemSet;
var itemModel = result.ItemModel;
var inventory = result.Inventory;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyReferenceOfByStampTask(
        new Gs2Inventory.VerifyReferenceOfByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const itemSet = result.getItemSet();
    const itemModel = result.getItemModel();
    const inventory = result.getInventory();
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_reference_of_by_stamp_task(
        inventory.VerifyReferenceOfByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    item = result.item
    item_set = result.item_set
    item_model = result.item_model
    inventory = result.inventory
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_reference_of_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.verify_reference_of_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemSet = result.itemSet;
itemModel = result.itemModel;
inventory = result.inventory;
newContextStack = result.newContextStack;

describeSimpleItems

Obtain list of simple items possession quantities

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Simple Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
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<SimpleItem>	List of Quantity of simple items
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeSimpleItems(
    &inventory.DescribeSimpleItemsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        AccessToken: pointy.String("accessToken-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeSimpleItemsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSimpleItems(
        (new DescribeSimpleItemsRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withAccessToken("accessToken-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeSimpleItemsRequest;
import io.gs2.inventory.result.DescribeSimpleItemsResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DescribeSimpleItemsResult result = client.describeSimpleItems(
        new DescribeSimpleItemsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<SimpleItem> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeSimpleItemsRequest;
using Gs2.Gs2Inventory.Result.DescribeSimpleItemsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DescribeSimpleItemsResult> asyncResult = null;
yield return client.DescribeSimpleItems(
    new Gs2.Gs2Inventory.Request.DescribeSimpleItemsRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.describeSimpleItems(
        new Gs2Inventory.DescribeSimpleItemsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.describe_simple_items(
        inventory.DescribeSimpleItemsRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_access_token('accessToken-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_simple_items({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('inventory')

api_result_handler = client.describe_simple_items_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeSimpleItemsByUserId

Obtain list of simple items possession quantities by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Simple Inventory Model Name
userId	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<SimpleItem>	List of Quantity of simple items
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeSimpleItemsByUserId(
    &inventory.DescribeSimpleItemsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeSimpleItemsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSimpleItemsByUserId(
        (new DescribeSimpleItemsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeSimpleItemsByUserIdRequest;
import io.gs2.inventory.result.DescribeSimpleItemsByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DescribeSimpleItemsByUserIdResult result = client.describeSimpleItemsByUserId(
        new DescribeSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<SimpleItem> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeSimpleItemsByUserIdRequest;
using Gs2.Gs2Inventory.Result.DescribeSimpleItemsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DescribeSimpleItemsByUserIdResult> asyncResult = null;
yield return client.DescribeSimpleItemsByUserId(
    new Gs2.Gs2Inventory.Request.DescribeSimpleItemsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.describeSimpleItemsByUserId(
        new Gs2Inventory.DescribeSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.describe_simple_items_by_user_id(
        inventory.DescribeSimpleItemsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_simple_items_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('inventory')

api_result_handler = client.describe_simple_items_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getSimpleItem

Get the quantity of simple items held

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
accessToken	string	✓	~ 128 chars	Access token
itemName	string	✓	~ 128 chars	Simple Item Model Name

Result

	Type	Description
item	SimpleItem	Quantity of simple items
itemModel	SimpleItemModel	Simple Item Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleItem(
    &inventory.GetSimpleItemRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemModel := result.ItemModel

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleItemRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleItem(
        (new GetSimpleItemRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
    );
    $item = $result->getItem();
    $itemModel = $result->getItemModel();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleItemRequest;
import io.gs2.inventory.result.GetSimpleItemResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetSimpleItemResult result = client.getSimpleItem(
        new GetSimpleItemRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
    );
    SimpleItem item = result.getItem();
    SimpleItemModel itemModel = result.getItemModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleItemRequest;
using Gs2.Gs2Inventory.Result.GetSimpleItemResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleItemResult> asyncResult = null;
yield return client.GetSimpleItem(
    new Gs2.Gs2Inventory.Request.GetSimpleItemRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemModel = result.ItemModel;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getSimpleItem(
        new Gs2Inventory.GetSimpleItemRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
    );
    const item = result.getItem();
    const itemModel = result.getItemModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_simple_item(
        inventory.GetSimpleItemRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
    )
    item = result.item
    item_model = result.item_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_item({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    itemName="item-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

client = gs2('inventory')

api_result_handler = client.get_simple_item_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    itemName="item-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

getSimpleItemByUserId

Obtain simple item possession quantity by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Simple Item Model Name
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	SimpleItem	Quantity of simple items
itemModel	SimpleItemModel	Simple Item Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleItemByUserId(
    &inventory.GetSimpleItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemModel := result.ItemModel

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleItemByUserId(
        (new GetSimpleItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $itemModel = $result->getItemModel();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleItemByUserIdRequest;
import io.gs2.inventory.result.GetSimpleItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetSimpleItemByUserIdResult result = client.getSimpleItemByUserId(
        new GetSimpleItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withTimeOffsetToken(null)
    );
    SimpleItem item = result.getItem();
    SimpleItemModel itemModel = result.getItemModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.GetSimpleItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleItemByUserIdResult> asyncResult = null;
yield return client.GetSimpleItemByUserId(
    new Gs2.Gs2Inventory.Request.GetSimpleItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemModel = result.ItemModel;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getSimpleItemByUserId(
        new Gs2Inventory.GetSimpleItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const itemModel = result.getItemModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_simple_item_by_user_id(
        inventory.GetSimpleItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    item_model = result.item_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_item_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

client = gs2('inventory')

api_result_handler = client.get_simple_item_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

getSimpleItemWithSignature

Get the quantity of simple items in your possession by expiration date along with your signature

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Simple Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
itemName	string	✓		~ 128 chars	Simple Item Model Name
keyId	string	✓	“grn:gs2:{region}:{ownerId}:key:default:key:default”	~ 1024 chars	encryption key GRN

Result

	Type	Description
item	SimpleItem	Quantity of simple items
simpleItemModel	SimpleItemModel	Simple Item Model
body	string	Simple Item Set Information for Signature Subject
signature	string	Signature

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleItemWithSignature(
    &inventory.GetSimpleItemWithSignatureRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
simpleItemModel := result.SimpleItemModel
body := result.Body
signature := result.Signature

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleItemWithSignatureRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleItemWithSignature(
        (new GetSimpleItemWithSignatureRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $simpleItemModel = $result->getSimpleItemModel();
    $body = $result->getBody();
    $signature = $result->getSignature();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleItemWithSignatureRequest;
import io.gs2.inventory.result.GetSimpleItemWithSignatureResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetSimpleItemWithSignatureResult result = client.getSimpleItemWithSignature(
        new GetSimpleItemWithSignatureRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withKeyId("key-0001")
    );
    SimpleItem item = result.getItem();
    SimpleItemModel simpleItemModel = result.getSimpleItemModel();
    String body = result.getBody();
    String signature = result.getSignature();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleItemWithSignatureRequest;
using Gs2.Gs2Inventory.Result.GetSimpleItemWithSignatureResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleItemWithSignatureResult> asyncResult = null;
yield return client.GetSimpleItemWithSignature(
    new Gs2.Gs2Inventory.Request.GetSimpleItemWithSignatureRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var simpleItemModel = result.SimpleItemModel;
var body = result.Body;
var signature = result.Signature;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getSimpleItemWithSignature(
        new Gs2Inventory.GetSimpleItemWithSignatureRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const simpleItemModel = result.getSimpleItemModel();
    const body = result.getBody();
    const signature = result.getSignature();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_simple_item_with_signature(
        inventory.GetSimpleItemWithSignatureRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_key_id('key-0001')
    )
    item = result.item
    simple_item_model = result.simple_item_model
    body = result.body
    signature = result.signature
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_item_with_signature({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
simpleItemModel = result.simpleItemModel;
body = result.body;
signature = result.signature;

client = gs2('inventory')

api_result_handler = client.get_simple_item_with_signature_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
simpleItemModel = result.simpleItemModel;
body = result.body;
signature = result.signature;

getSimpleItemWithSignatureByUserId

Obtain the quantity of simple items held by specifying the user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Simple Inventory Model Name
userId	string	✓		~ 128 chars	User Id
itemName	string	✓		~ 128 chars	Simple Item Model Name
keyId	string	✓	“grn:gs2:{region}:{ownerId}:key:default:key:default”	~ 1024 chars	encryption key GRN
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	SimpleItem	Quantity of simple items
simpleItemModel	SimpleItemModel	Simple Item Model
body	string	Simple Item Set Information for Signature Subject
signature	string	Signature

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetSimpleItemWithSignatureByUserId(
    &inventory.GetSimpleItemWithSignatureByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        KeyId: pointy.String("key-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
simpleItemModel := result.SimpleItemModel
body := result.Body
signature := result.Signature

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetSimpleItemWithSignatureByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSimpleItemWithSignatureByUserId(
        (new GetSimpleItemWithSignatureByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withKeyId("key-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $simpleItemModel = $result->getSimpleItemModel();
    $body = $result->getBody();
    $signature = $result->getSignature();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetSimpleItemWithSignatureByUserIdRequest;
import io.gs2.inventory.result.GetSimpleItemWithSignatureByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetSimpleItemWithSignatureByUserIdResult result = client.getSimpleItemWithSignatureByUserId(
        new GetSimpleItemWithSignatureByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withKeyId("key-0001")
            .withTimeOffsetToken(null)
    );
    SimpleItem item = result.getItem();
    SimpleItemModel simpleItemModel = result.getSimpleItemModel();
    String body = result.getBody();
    String signature = result.getSignature();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetSimpleItemWithSignatureByUserIdRequest;
using Gs2.Gs2Inventory.Result.GetSimpleItemWithSignatureByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetSimpleItemWithSignatureByUserIdResult> asyncResult = null;
yield return client.GetSimpleItemWithSignatureByUserId(
    new Gs2.Gs2Inventory.Request.GetSimpleItemWithSignatureByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithKeyId("key-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var simpleItemModel = result.SimpleItemModel;
var body = result.Body;
var signature = result.Signature;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getSimpleItemWithSignatureByUserId(
        new Gs2Inventory.GetSimpleItemWithSignatureByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withKeyId("key-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const simpleItemModel = result.getSimpleItemModel();
    const body = result.getBody();
    const signature = result.getSignature();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_simple_item_with_signature_by_user_id(
        inventory.GetSimpleItemWithSignatureByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_key_id('key-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    simple_item_model = result.simple_item_model
    body = result.body
    signature = result.signature
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_simple_item_with_signature_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    keyId="key-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
simpleItemModel = result.simpleItemModel;
body = result.body;
signature = result.signature;

client = gs2('inventory')

api_result_handler = client.get_simple_item_with_signature_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    keyId="key-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
simpleItemModel = result.simpleItemModel;
body = result.body;
signature = result.signature;

acquireSimpleItemsByUserId

Acquire simple items by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
userId	string	✓	~ 128 chars	User Id
acquireCounts	List<AcquireCount>	✓	1 ~ 100 items	List of quantity of simple items to be obtained
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
items	List<SimpleItem>	List of simple item possession quantities after addition

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireSimpleItemsByUserId(
    &inventory.AcquireSimpleItemsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        UserId: pointy.String("user-0001"),
        AcquireCounts: []inventory.AcquireCount{
            inventory.AcquireCount{
                ItemName: pointy.String("item-0001"),
                Count: pointy.Int64(5),
            },
        },
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireSimpleItemsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireSimpleItemsByUserId(
        (new AcquireSimpleItemsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withUserId("user-0001")
            ->withAcquireCounts([
                (new \Gs2\Inventory\Model\AcquireCount())
                    ->withItemName("item-0001")
                    ->withCount(5),
            ])
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireSimpleItemsByUserIdRequest;
import io.gs2.inventory.result.AcquireSimpleItemsByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireSimpleItemsByUserIdResult result = client.acquireSimpleItemsByUserId(
        new AcquireSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withAcquireCounts(Arrays.asList(
                new io.gs2.inventory.model.AcquireCount()
                    .withItemName("item-0001")
                    .withCount(5L)
            ))
            .withTimeOffsetToken(null)
    );
    List<SimpleItem> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireSimpleItemsByUserIdRequest;
using Gs2.Gs2Inventory.Result.AcquireSimpleItemsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireSimpleItemsByUserIdResult> asyncResult = null;
yield return client.AcquireSimpleItemsByUserId(
    new Gs2.Gs2Inventory.Request.AcquireSimpleItemsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithUserId("user-0001")
        .WithAcquireCounts(new Gs2.Gs2Inventory.Model.AcquireCount[] {
            new Gs2.Gs2Inventory.Model.AcquireCount()
                .WithItemName("item-0001")
                .WithCount(5L),
        })
        .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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireSimpleItemsByUserId(
        new Gs2Inventory.AcquireSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withAcquireCounts([
                new Gs2Inventory.model.AcquireCount()
                    .withItemName("item-0001")
                    .withCount(5),
            ])
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_simple_items_by_user_id(
        inventory.AcquireSimpleItemsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_user_id('user-0001')
            .with_acquire_counts([
                inventory.AcquireCount()
                    .with_item_name('item-0001')
                    .with_count(5),
            ])
            .with_time_offset_token(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_simple_items_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    acquireCounts={
        {
            itemName="item-0001",
            count=5,
        }
    },
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.acquire_simple_items_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    acquireCounts={
        {
            itemName="item-0001",
            count=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['message'])
end

result = api_result.result
items = result.items;

consumeSimpleItems

Consume simple items

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
accessToken	string	✓	~ 128 chars	Access token
consumeCounts	List<ConsumeCount>	✓	1 ~ 100 items	List of quantity of simple items to be consumed

Result

	Type	Description
items	List<SimpleItem>	List of simple items possession quantities per post-consumption

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeSimpleItems(
    &inventory.ConsumeSimpleItemsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ConsumeCounts: []inventory.ConsumeCount{
            inventory.ConsumeCount{
                ItemName: pointy.String("item-0001"),
                Count: pointy.Int64(5),
            },
            inventory.ConsumeCount{
                ItemName: pointy.String("item-0002"),
                Count: pointy.Int64(3),
            },
        },
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeSimpleItemsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeSimpleItems(
        (new ConsumeSimpleItemsRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withConsumeCounts([
                (new ConsumeCount())
                    ->withItemName("item-0001")
                    ->withCount(5),
                (new ConsumeCount())
                    ->withItemName("item-0002")
                    ->withCount(3),
            ])
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeSimpleItemsRequest;
import io.gs2.inventory.result.ConsumeSimpleItemsResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeSimpleItemsResult result = client.consumeSimpleItems(
        new ConsumeSimpleItemsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withConsumeCounts(Arrays.asList(
                new ConsumeCount()
                    .withItemName("item-0001")
                    .withCount(5L),
                new ConsumeCount()
                    .withItemName("item-0002")
                    .withCount(3L)
            ))
    );
    List<SimpleItem> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeSimpleItemsRequest;
using Gs2.Gs2Inventory.Result.ConsumeSimpleItemsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeSimpleItemsResult> asyncResult = null;
yield return client.ConsumeSimpleItems(
    new Gs2.Gs2Inventory.Request.ConsumeSimpleItemsRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithConsumeCounts(new Gs2.Gs2Inventory.Model.ConsumeCount[] {
            new Gs2.Gs2Inventory.Model.ConsumeCount()
                .WithItemName("item-0001")
                .WithCount(5L),
            new Gs2.Gs2Inventory.Model.ConsumeCount()
                .WithItemName("item-0002")
                .WithCount(3L),
        }),
    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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeSimpleItems(
        new Gs2Inventory.ConsumeSimpleItemsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withConsumeCounts([
                new Gs2Inventory.model.ConsumeCount()
                    .withItemName("item-0001")
                    .withCount(5),
                new Gs2Inventory.model.ConsumeCount()
                    .withItemName("item-0002")
                    .withCount(3),
            ])
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_simple_items(
        inventory.ConsumeSimpleItemsRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_consume_counts([
                inventory.ConsumeCount()
                    .with_item_name('item-0001')
                    .with_count(5),
                inventory.ConsumeCount()
                    .with_item_name('item-0002')
                    .with_count(3),
            ])
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_simple_items({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    consumeCounts={
        {
            item_name="item-0001",
            count=5,
        },
        {
            item_name="item-0002",
            count=3,
        }
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.consume_simple_items_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    consumeCounts={
        {
            item_name="item-0001",
            count=5,
        },
        {
            item_name="item-0002",
            count=3,
        }
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

consumeSimpleItemsByUserId

Consume simple items by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
userId	string	✓	~ 128 chars	User Id
consumeCounts	List<ConsumeCount>	✓	1 ~ 100 items	List of quantity of simple items to be consumed
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
items	List<SimpleItem>	List of simple items possession quantities per post-consumption

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeSimpleItemsByUserId(
    &inventory.ConsumeSimpleItemsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ConsumeCounts: []inventory.ConsumeCount{
            inventory.ConsumeCount{
                ItemName: pointy.String("item-0001"),
                Count: pointy.Int64(5),
            },
            inventory.ConsumeCount{
                ItemName: pointy.String("item-0002"),
                Count: pointy.Int64(3),
            },
        },
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeSimpleItemsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeSimpleItemsByUserId(
        (new ConsumeSimpleItemsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withConsumeCounts([
                (new ConsumeCount())
                    ->withItemName("item-0001")
                    ->withCount(5),
                (new ConsumeCount())
                    ->withItemName("item-0002")
                    ->withCount(3),
            ])
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeSimpleItemsByUserIdRequest;
import io.gs2.inventory.result.ConsumeSimpleItemsByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeSimpleItemsByUserIdResult result = client.consumeSimpleItemsByUserId(
        new ConsumeSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withConsumeCounts(Arrays.asList(
                new ConsumeCount()
                    .withItemName("item-0001")
                    .withCount(5L),
                new ConsumeCount()
                    .withItemName("item-0002")
                    .withCount(3L)
            ))
            .withTimeOffsetToken(null)
    );
    List<SimpleItem> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeSimpleItemsByUserIdRequest;
using Gs2.Gs2Inventory.Result.ConsumeSimpleItemsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeSimpleItemsByUserIdResult> asyncResult = null;
yield return client.ConsumeSimpleItemsByUserId(
    new Gs2.Gs2Inventory.Request.ConsumeSimpleItemsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithConsumeCounts(new Gs2.Gs2Inventory.Model.ConsumeCount[] {
            new Gs2.Gs2Inventory.Model.ConsumeCount()
                .WithItemName("item-0001")
                .WithCount(5L),
            new Gs2.Gs2Inventory.Model.ConsumeCount()
                .WithItemName("item-0002")
                .WithCount(3L),
        })
        .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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeSimpleItemsByUserId(
        new Gs2Inventory.ConsumeSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withConsumeCounts([
                new Gs2Inventory.model.ConsumeCount()
                    .withItemName("item-0001")
                    .withCount(5),
                new Gs2Inventory.model.ConsumeCount()
                    .withItemName("item-0002")
                    .withCount(3),
            ])
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_simple_items_by_user_id(
        inventory.ConsumeSimpleItemsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_consume_counts([
                inventory.ConsumeCount()
                    .with_item_name('item-0001')
                    .with_count(5),
                inventory.ConsumeCount()
                    .with_item_name('item-0002')
                    .with_count(3),
            ])
            .with_time_offset_token(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_simple_items_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    consumeCounts={
        {
            item_name="item-0001",
            count=5,
        },
        {
            item_name="item-0002",
            count=3,
        }
    },
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.consume_simple_items_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    consumeCounts={
        {
            item_name="item-0001",
            count=5,
        },
        {
            item_name="item-0002",
            count=3,
        }
    },
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

setSimpleItemsByUserId

Set the quantity of simple items by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
userId	string	✓	~ 128 chars	User Id
counts	List<HeldCount>	✓	1 ~ 100 items	List of quantity of simple items to be obtained
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
items	List<SimpleItem>	List of simple item possession quantities after update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.SetSimpleItemsByUserId(
    &inventory.SetSimpleItemsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        Counts: []inventory.HeldCount{
            inventory.HeldCount{
                ItemName: pointy.String("item-0001"),
                Count: pointy.Int64(5),
            },
            inventory.HeldCount{
                ItemName: pointy.String("item-0002"),
                Count: pointy.Int64(3),
            },
        },
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\SetSimpleItemsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setSimpleItemsByUserId(
        (new SetSimpleItemsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withCounts([
                (new HeldCount())
                    ->withItemName("item-0001")
                    ->withCount(5),
                (new HeldCount())
                    ->withItemName("item-0002")
                    ->withCount(3),
            ])
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.SetSimpleItemsByUserIdRequest;
import io.gs2.inventory.result.SetSimpleItemsByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    SetSimpleItemsByUserIdResult result = client.setSimpleItemsByUserId(
        new SetSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withCounts(Arrays.asList(
                new HeldCount()
                    .withItemName("item-0001")
                    .withCount(5L),
                new HeldCount()
                    .withItemName("item-0002")
                    .withCount(3L)
            ))
            .withTimeOffsetToken(null)
    );
    List<SimpleItem> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.SetSimpleItemsByUserIdRequest;
using Gs2.Gs2Inventory.Result.SetSimpleItemsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.SetSimpleItemsByUserIdResult> asyncResult = null;
yield return client.SetSimpleItemsByUserId(
    new Gs2.Gs2Inventory.Request.SetSimpleItemsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithCounts(new Gs2.Gs2Inventory.Model.HeldCount[] {
            new Gs2.Gs2Inventory.Model.HeldCount()
                .WithItemName("item-0001")
                .WithCount(5L),
            new Gs2.Gs2Inventory.Model.HeldCount()
                .WithItemName("item-0002")
                .WithCount(3L),
        })
        .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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.setSimpleItemsByUserId(
        new Gs2Inventory.SetSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withCounts([
                new Gs2Inventory.model.HeldCount()
                    .withItemName("item-0001")
                    .withCount(5),
                new Gs2Inventory.model.HeldCount()
                    .withItemName("item-0002")
                    .withCount(3),
            ])
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.set_simple_items_by_user_id(
        inventory.SetSimpleItemsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_counts([
                inventory.HeldCount()
                    .with_item_name('item-0001')
                    .with_count(5),
                inventory.HeldCount()
                    .with_item_name('item-0002')
                    .with_count(3),
            ])
            .with_time_offset_token(None)
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.set_simple_items_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    counts={
        {
            item_name="item-0001",
            count=5,
        },
        {
            item_name="item-0002",
            count=3,
        }
    },
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.set_simple_items_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    counts={
        {
            item_name="item-0001",
            count=5,
        },
        {
            item_name="item-0002",
            count=3,
        }
    },
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

deleteSimpleItemsByUserId

Delete simple item possession quantities

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Simple Inventory Model Name
userId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteSimpleItemsByUserId(
    &inventory.DeleteSimpleItemsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteSimpleItemsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteSimpleItemsByUserId(
        (new DeleteSimpleItemsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteSimpleItemsByUserIdRequest;
import io.gs2.inventory.result.DeleteSimpleItemsByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DeleteSimpleItemsByUserIdResult result = client.deleteSimpleItemsByUserId(
        new DeleteSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteSimpleItemsByUserIdRequest;
using Gs2.Gs2Inventory.Result.DeleteSimpleItemsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DeleteSimpleItemsByUserIdResult> asyncResult = null;
yield return client.DeleteSimpleItemsByUserId(
    new Gs2.Gs2Inventory.Request.DeleteSimpleItemsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.deleteSimpleItemsByUserId(
        new Gs2Inventory.DeleteSimpleItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.delete_simple_items_by_user_id(
        inventory.DeleteSimpleItemsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_simple_items_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('inventory')

api_result_handler = client.delete_simple_items_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

verifySimpleItem

Verify the quantity of possessions in simple items

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	Access token
inventoryName	string	✓		~ 128 chars	Simple Inventory Model Name
itemName	string	✓		~ 128 chars	Simple Item Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
count	long	✓		~ 9223372036854775805	Quantity in possession
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Possession quantity is less than the specified value
lessEqual	Possession quantity is less than or equal to the specified value
greater	Possession quantity is greater than the specified value
greaterEqual	Possession quantity is greater than or equal to the specified value
equal	Possession quantity is equal to the specified value
notEqual	Possession quantity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifySimpleItem(
    &inventory.VerifySimpleItemRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        InventoryName: pointy.String("inventory-0001"),
        ItemName: pointy.String("item-0001"),
        VerifyType: pointy.String("less"),
        Count: pointy.Int64(10),
        MultiplyValueSpecifyingQuantity: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifySimpleItemRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifySimpleItem(
        (new VerifySimpleItemRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withInventoryName("inventory-0001")
            ->withItemName("item-0001")
            ->withVerifyType("less")
            ->withCount(10)
            ->withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifySimpleItemRequest;
import io.gs2.inventory.result.VerifySimpleItemResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifySimpleItemResult result = client.verifySimpleItem(
        new VerifySimpleItemRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10L)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifySimpleItemRequest;
using Gs2.Gs2Inventory.Result.VerifySimpleItemResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifySimpleItemResult> asyncResult = null;
yield return client.VerifySimpleItem(
    new Gs2.Gs2Inventory.Request.VerifySimpleItemRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithInventoryName("inventory-0001")
        .WithItemName("item-0001")
        .WithVerifyType("less")
        .WithCount(10L)
        .WithMultiplyValueSpecifyingQuantity(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifySimpleItem(
        new Gs2Inventory.VerifySimpleItemRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_simple_item(
        inventory.VerifySimpleItemRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_inventory_name('inventory-0001')
            .with_item_name('item-0001')
            .with_verify_type('less')
            .with_count(10)
            .with_multiply_value_specifying_quantity(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_simple_item({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_simple_item_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

verifySimpleItemByUserId

Verify the quantity of possessions in simple items by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
inventoryName	string	✓		~ 128 chars	Simple Inventory Model Name
itemName	string	✓		~ 128 chars	Simple Item Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
count	long	✓		~ 9223372036854775805	Quantity in possession
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity
timeOffsetToken	string			~ 1024 chars	Time offset token

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Possession quantity is less than the specified value
lessEqual	Possession quantity is less than or equal to the specified value
greater	Possession quantity is greater than the specified value
greaterEqual	Possession quantity is greater than or equal to the specified value
equal	Possession quantity is equal to the specified value
notEqual	Possession quantity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifySimpleItemByUserId(
    &inventory.VerifySimpleItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        InventoryName: pointy.String("inventory-0001"),
        ItemName: pointy.String("item-0001"),
        VerifyType: pointy.String("less"),
        Count: pointy.Int64(10),
        MultiplyValueSpecifyingQuantity: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifySimpleItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifySimpleItemByUserId(
        (new VerifySimpleItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withInventoryName("inventory-0001")
            ->withItemName("item-0001")
            ->withVerifyType("less")
            ->withCount(10)
            ->withMultiplyValueSpecifyingQuantity(null)
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifySimpleItemByUserIdRequest;
import io.gs2.inventory.result.VerifySimpleItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifySimpleItemByUserIdResult result = client.verifySimpleItemByUserId(
        new VerifySimpleItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10L)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifySimpleItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.VerifySimpleItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifySimpleItemByUserIdResult> asyncResult = null;
yield return client.VerifySimpleItemByUserId(
    new Gs2.Gs2Inventory.Request.VerifySimpleItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithInventoryName("inventory-0001")
        .WithItemName("item-0001")
        .WithVerifyType("less")
        .WithCount(10L)
        .WithMultiplyValueSpecifyingQuantity(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifySimpleItemByUserId(
        new Gs2Inventory.VerifySimpleItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_simple_item_by_user_id(
        inventory.VerifySimpleItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_inventory_name('inventory-0001')
            .with_item_name('item-0001')
            .with_verify_type('less')
            .with_count(10)
            .with_multiply_value_specifying_quantity(None)
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_simple_item_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_simple_item_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

acquireSimpleItemsByStampSheet

Execute the acquisition of simple items as an acquire action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
items	List<SimpleItem>	List of Quantity of simple items after addition

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireSimpleItemsByStampSheet(
    &inventory.AcquireSimpleItemsByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireSimpleItemsByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireSimpleItemsByStampSheet(
        (new AcquireSimpleItemsByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireSimpleItemsByStampSheetRequest;
import io.gs2.inventory.result.AcquireSimpleItemsByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireSimpleItemsByStampSheetResult result = client.acquireSimpleItemsByStampSheet(
        new AcquireSimpleItemsByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    List<SimpleItem> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireSimpleItemsByStampSheetRequest;
using Gs2.Gs2Inventory.Result.AcquireSimpleItemsByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireSimpleItemsByStampSheetResult> asyncResult = null;
yield return client.AcquireSimpleItemsByStampSheet(
    new Gs2.Gs2Inventory.Request.AcquireSimpleItemsByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireSimpleItemsByStampSheet(
        new Gs2Inventory.AcquireSimpleItemsByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_simple_items_by_stamp_sheet(
        inventory.AcquireSimpleItemsByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_simple_items_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.acquire_simple_items_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

consumeSimpleItemsByStampTask

Execute the consumption of simple items as a consume action

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Consume Action
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
items	List<SimpleItem>	List of Quantity of simple items held per post-consumption
newContextStack	string	Request of context in which consume action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeSimpleItemsByStampTask(
    &inventory.ConsumeSimpleItemsByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeSimpleItemsByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeSimpleItemsByStampTask(
        (new ConsumeSimpleItemsByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $items = $result->getItems();
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeSimpleItemsByStampTaskRequest;
import io.gs2.inventory.result.ConsumeSimpleItemsByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeSimpleItemsByStampTaskResult result = client.consumeSimpleItemsByStampTask(
        new ConsumeSimpleItemsByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    List<SimpleItem> items = result.getItems();
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeSimpleItemsByStampTaskRequest;
using Gs2.Gs2Inventory.Result.ConsumeSimpleItemsByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeSimpleItemsByStampTaskResult> asyncResult = null;
yield return client.ConsumeSimpleItemsByStampTask(
    new Gs2.Gs2Inventory.Request.ConsumeSimpleItemsByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeSimpleItemsByStampTask(
        new Gs2Inventory.ConsumeSimpleItemsByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const items = result.getItems();
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_simple_items_by_stamp_task(
        inventory.ConsumeSimpleItemsByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    items = result.items
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_simple_items_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.consume_simple_items_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
newContextStack = result.newContextStack;

setSimpleItemsByStampSheet

Execute setting of any value for the quantity of simple items as a acquire action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
items	List<SimpleItem>	List of Quantity of simple items after update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.SetSimpleItemsByStampSheet(
    &inventory.SetSimpleItemsByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\SetSimpleItemsByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setSimpleItemsByStampSheet(
        (new SetSimpleItemsByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.SetSimpleItemsByStampSheetRequest;
import io.gs2.inventory.result.SetSimpleItemsByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    SetSimpleItemsByStampSheetResult result = client.setSimpleItemsByStampSheet(
        new SetSimpleItemsByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    List<SimpleItem> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.SetSimpleItemsByStampSheetRequest;
using Gs2.Gs2Inventory.Result.SetSimpleItemsByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.SetSimpleItemsByStampSheetResult> asyncResult = null;
yield return client.SetSimpleItemsByStampSheet(
    new Gs2.Gs2Inventory.Request.SetSimpleItemsByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.setSimpleItemsByStampSheet(
        new Gs2Inventory.SetSimpleItemsByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.set_simple_items_by_stamp_sheet(
        inventory.SetSimpleItemsByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.set_simple_items_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

client = gs2('inventory')

api_result_handler = client.set_simple_items_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;

verifySimpleItemByStampTask

Execute the verification of the quantity of simple items as a verify action

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Verify Action
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
newContextStack	string	Request of context in which verify action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifySimpleItemByStampTask(
    &inventory.VerifySimpleItemByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifySimpleItemByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifySimpleItemByStampTask(
        (new VerifySimpleItemByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifySimpleItemByStampTaskRequest;
import io.gs2.inventory.result.VerifySimpleItemByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifySimpleItemByStampTaskResult result = client.verifySimpleItemByStampTask(
        new VerifySimpleItemByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifySimpleItemByStampTaskRequest;
using Gs2.Gs2Inventory.Result.VerifySimpleItemByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifySimpleItemByStampTaskResult> asyncResult = null;
yield return client.VerifySimpleItemByStampTask(
    new Gs2.Gs2Inventory.Request.VerifySimpleItemByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifySimpleItemByStampTask(
        new Gs2Inventory.VerifySimpleItemByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_simple_item_by_stamp_task(
        inventory.VerifySimpleItemByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_simple_item_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.verify_simple_item_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;

describeBigItems

Obtain list of big items possession quantities by expiration date

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Big Inventory Model Name
accessToken	string	✓		~ 128 chars	Access token
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<BigItem>	List of Quantity of big items
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeBigItems(
    &inventory.DescribeBigItemsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        AccessToken: pointy.String("accessToken-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeBigItemsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBigItems(
        (new DescribeBigItemsRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withAccessToken("accessToken-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeBigItemsRequest;
import io.gs2.inventory.result.DescribeBigItemsResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DescribeBigItemsResult result = client.describeBigItems(
        new DescribeBigItemsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<BigItem> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeBigItemsRequest;
using Gs2.Gs2Inventory.Result.DescribeBigItemsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DescribeBigItemsResult> asyncResult = null;
yield return client.DescribeBigItems(
    new Gs2.Gs2Inventory.Request.DescribeBigItemsRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.describeBigItems(
        new Gs2Inventory.DescribeBigItemsRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.describe_big_items(
        inventory.DescribeBigItemsRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_access_token('accessToken-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_big_items({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('inventory')

api_result_handler = client.describe_big_items_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeBigItemsByUserId

Obtain a list of big items possession quantities by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
inventoryName	string	✓		~ 128 chars	Big Inventory Model Name
userId	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<BigItem>	List of Quantity of big items
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/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DescribeBigItemsByUserId(
    &inventory.DescribeBigItemsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DescribeBigItemsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBigItemsByUserId(
        (new DescribeBigItemsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DescribeBigItemsByUserIdRequest;
import io.gs2.inventory.result.DescribeBigItemsByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DescribeBigItemsByUserIdResult result = client.describeBigItemsByUserId(
        new DescribeBigItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<BigItem> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DescribeBigItemsByUserIdRequest;
using Gs2.Gs2Inventory.Result.DescribeBigItemsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DescribeBigItemsByUserIdResult> asyncResult = null;
yield return client.DescribeBigItemsByUserId(
    new Gs2.Gs2Inventory.Request.DescribeBigItemsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.describeBigItemsByUserId(
        new Gs2Inventory.DescribeBigItemsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.describe_big_items_by_user_id(
        inventory.DescribeBigItemsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.describe_big_items_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('inventory')

api_result_handler = client.describe_big_items_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getBigItem

Get the quantity of big items held by expiration date

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
accessToken	string	✓	~ 128 chars	Access token
itemName	string	✓	~ 128 chars	Big Item Model Name

Result

	Type	Description
item	BigItem	Quantity of big items
itemModel	BigItemModel	Big Item Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetBigItem(
    &inventory.GetBigItemRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemModel := result.ItemModel

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetBigItemRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBigItem(
        (new GetBigItemRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
    );
    $item = $result->getItem();
    $itemModel = $result->getItemModel();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetBigItemRequest;
import io.gs2.inventory.result.GetBigItemResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetBigItemResult result = client.getBigItem(
        new GetBigItemRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
    );
    BigItem item = result.getItem();
    BigItemModel itemModel = result.getItemModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetBigItemRequest;
using Gs2.Gs2Inventory.Result.GetBigItemResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetBigItemResult> asyncResult = null;
yield return client.GetBigItem(
    new Gs2.Gs2Inventory.Request.GetBigItemRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemModel = result.ItemModel;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getBigItem(
        new Gs2Inventory.GetBigItemRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
    );
    const item = result.getItem();
    const itemModel = result.getItemModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_big_item(
        inventory.GetBigItemRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
    )
    item = result.item
    item_model = result.item_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_big_item({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    itemName="item-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

client = gs2('inventory')

api_result_handler = client.get_big_item_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    accessToken="accessToken-0001",
    itemName="item-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

getBigItemByUserId

Obtain the quantity of big items held by expiration date by specifying the user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Big Item Model Name
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BigItem	Quantity of big items
itemModel	BigItemModel	Big Item Model

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.GetBigItemByUserId(
    &inventory.GetBigItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
itemModel := result.ItemModel

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\GetBigItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getBigItemByUserId(
        (new GetBigItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $itemModel = $result->getItemModel();
} 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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.GetBigItemByUserIdRequest;
import io.gs2.inventory.result.GetBigItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    GetBigItemByUserIdResult result = client.getBigItemByUserId(
        new GetBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withTimeOffsetToken(null)
    );
    BigItem item = result.getItem();
    BigItemModel itemModel = result.getItemModel();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.GetBigItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.GetBigItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.GetBigItemByUserIdResult> asyncResult = null;
yield return client.GetBigItemByUserId(
    new Gs2.Gs2Inventory.Request.GetBigItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var itemModel = result.ItemModel;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.getBigItemByUserId(
        new Gs2Inventory.GetBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const itemModel = result.getItemModel();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.get_big_item_by_user_id(
        inventory.GetBigItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    item_model = result.item_model
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.get_big_item_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

client = gs2('inventory')

api_result_handler = client.get_big_item_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
itemModel = result.itemModel;

acquireBigItemByUserId

Acquire big items by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Big Item Model Name
acquireCount	string	✓	~ 1024 chars	Quantity of big items to be obtained
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BigItem	Quantity of big items after addition

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireBigItemByUserId(
    &inventory.AcquireBigItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        AcquireCount: pointy.String("1234567890123456789012345678901234567890"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireBigItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireBigItemByUserId(
        (new AcquireBigItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withAcquireCount("1234567890123456789012345678901234567890")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireBigItemByUserIdRequest;
import io.gs2.inventory.result.AcquireBigItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireBigItemByUserIdResult result = client.acquireBigItemByUserId(
        new AcquireBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withAcquireCount("1234567890123456789012345678901234567890")
            .withTimeOffsetToken(null)
    );
    BigItem item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireBigItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.AcquireBigItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireBigItemByUserIdResult> asyncResult = null;
yield return client.AcquireBigItemByUserId(
    new Gs2.Gs2Inventory.Request.AcquireBigItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithAcquireCount("1234567890123456789012345678901234567890")
        .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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireBigItemByUserId(
        new Gs2Inventory.AcquireBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withAcquireCount("1234567890123456789012345678901234567890")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_big_item_by_user_id(
        inventory.AcquireBigItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_acquire_count('1234567890123456789012345678901234567890')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_big_item_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    itemName="item-0001",
    acquireCount="1234567890123456789012345678901234567890",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.acquire_big_item_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    itemName="item-0001",
    acquireCount="1234567890123456789012345678901234567890",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

consumeBigItem

Consume big items

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
accessToken	string	✓	~ 128 chars	Access token
itemName	string	✓	~ 128 chars	Big Item Model Name
consumeCount	string	✓	~ 1024 chars	Quantity of big items to be consumed

Result

	Type	Description
item	BigItem	Quantity of big items held per post-consumption expiration date

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeBigItem(
    &inventory.ConsumeBigItemRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        ItemName: pointy.String("item-0001"),
        ConsumeCount: pointy.String("1234567890123456789012345678901234567890"),
    }
)
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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeBigItemRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeBigItem(
        (new ConsumeBigItemRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withAccessToken("accessToken-0001")
            ->withItemName("item-0001")
            ->withConsumeCount("1234567890123456789012345678901234567890")
    );
    $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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeBigItemRequest;
import io.gs2.inventory.result.ConsumeBigItemResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeBigItemResult result = client.consumeBigItem(
        new ConsumeBigItemRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withConsumeCount("1234567890123456789012345678901234567890")
    );
    BigItem item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeBigItemRequest;
using Gs2.Gs2Inventory.Result.ConsumeBigItemResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeBigItemResult> asyncResult = null;
yield return client.ConsumeBigItem(
    new Gs2.Gs2Inventory.Request.ConsumeBigItemRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithAccessToken("accessToken-0001")
        .WithItemName("item-0001")
        .WithConsumeCount("1234567890123456789012345678901234567890"),
    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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeBigItem(
        new Gs2Inventory.ConsumeBigItemRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withAccessToken("accessToken-0001")
            .withItemName("item-0001")
            .withConsumeCount("1234567890123456789012345678901234567890")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_big_item(
        inventory.ConsumeBigItemRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_access_token('accessToken-0001')
            .with_item_name('item-0001')
            .with_consume_count('1234567890123456789012345678901234567890')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_big_item({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    consumeCount="1234567890123456789012345678901234567890",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.consume_big_item_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    accessToken="accessToken-0001",
    itemName="item-0001",
    consumeCount="1234567890123456789012345678901234567890",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

consumeBigItemByUserId

Consume big items by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Big Item Model Name
consumeCount	string	✓	~ 1024 chars	Quantity of big items to be consumed
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BigItem	Quantity of big items held per post-consumption expiration date

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeBigItemByUserId(
    &inventory.ConsumeBigItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        ConsumeCount: pointy.String("1234567890123456789012345678901234567890"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeBigItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeBigItemByUserId(
        (new ConsumeBigItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withConsumeCount("1234567890123456789012345678901234567890")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeBigItemByUserIdRequest;
import io.gs2.inventory.result.ConsumeBigItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeBigItemByUserIdResult result = client.consumeBigItemByUserId(
        new ConsumeBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withConsumeCount("1234567890123456789012345678901234567890")
            .withTimeOffsetToken(null)
    );
    BigItem item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeBigItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.ConsumeBigItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeBigItemByUserIdResult> asyncResult = null;
yield return client.ConsumeBigItemByUserId(
    new Gs2.Gs2Inventory.Request.ConsumeBigItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithConsumeCount("1234567890123456789012345678901234567890")
        .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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeBigItemByUserId(
        new Gs2Inventory.ConsumeBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withConsumeCount("1234567890123456789012345678901234567890")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_big_item_by_user_id(
        inventory.ConsumeBigItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_consume_count('1234567890123456789012345678901234567890')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_big_item_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    consumeCount="1234567890123456789012345678901234567890",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.consume_big_item_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    consumeCount="1234567890123456789012345678901234567890",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

setBigItemByUserId

Set the quantity of big items by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Big Item Model Name
count	string	✓	~ 1024 chars	Quantity of big items to be set
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BigItem	Quantity of big items after update

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.SetBigItemByUserId(
    &inventory.SetBigItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("inventory-0001"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        Count: pointy.String("1234567890123456789012345678901234567890"),
        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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\SetBigItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setBigItemByUserId(
        (new SetBigItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("inventory-0001")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withCount("1234567890123456789012345678901234567890")
            ->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.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.SetBigItemByUserIdRequest;
import io.gs2.inventory.result.SetBigItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    SetBigItemByUserIdResult result = client.setBigItemByUserId(
        new SetBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withCount("1234567890123456789012345678901234567890")
            .withTimeOffsetToken(null)
    );
    BigItem item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.SetBigItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.SetBigItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.SetBigItemByUserIdResult> asyncResult = null;
yield return client.SetBigItemByUserId(
    new Gs2.Gs2Inventory.Request.SetBigItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("inventory-0001")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithCount("1234567890123456789012345678901234567890")
        .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 Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.setBigItemByUserId(
        new Gs2Inventory.SetBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("inventory-0001")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withCount("1234567890123456789012345678901234567890")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.set_big_item_by_user_id(
        inventory.SetBigItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('inventory-0001')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_count('1234567890123456789012345678901234567890')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.set_big_item_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    count="1234567890123456789012345678901234567890",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.set_big_item_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="inventory-0001",
    userId="user-0001",
    itemName="item-0001",
    count="1234567890123456789012345678901234567890",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteBigItemByUserId

Delete big item possession quantity

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
inventoryName	string	✓	~ 128 chars	Big Inventory Model Name
userId	string	✓	~ 128 chars	User Id
itemName	string	✓	~ 128 chars	Big Item Model Name
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BigItem	Quantity of big items held per post-consumption expiration date

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.DeleteBigItemByUserId(
    &inventory.DeleteBigItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        InventoryName: pointy.String("item"),
        UserId: pointy.String("user-0001"),
        ItemName: pointy.String("item-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\DeleteBigItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteBigItemByUserId(
        (new DeleteBigItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withInventoryName("item")
            ->withUserId("user-0001")
            ->withItemName("item-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.DeleteBigItemByUserIdRequest;
import io.gs2.inventory.result.DeleteBigItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    DeleteBigItemByUserIdResult result = client.deleteBigItemByUserId(
        new DeleteBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withTimeOffsetToken(null)
    );
    BigItem item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.DeleteBigItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.DeleteBigItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.DeleteBigItemByUserIdResult> asyncResult = null;
yield return client.DeleteBigItemByUserId(
    new Gs2.Gs2Inventory.Request.DeleteBigItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithInventoryName("item")
        .WithUserId("user-0001")
        .WithItemName("item-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.deleteBigItemByUserId(
        new Gs2Inventory.DeleteBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withInventoryName("item")
            .withUserId("user-0001")
            .withItemName("item-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.delete_big_item_by_user_id(
        inventory.DeleteBigItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_inventory_name('item')
            .with_user_id('user-0001')
            .with_item_name('item-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.delete_big_item_by_user_id({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    itemName="item-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.delete_big_item_by_user_id_async({
    namespaceName="namespace-0001",
    inventoryName="item",
    userId="user-0001",
    itemName="item-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

verifyBigItem

Verify possession quantity of big items

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	Access token
inventoryName	string	✓		~ 128 chars	Big Inventory Model Name
itemName	string	✓		~ 128 chars	Big Item Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
count	string	✓		~ 1024 chars	Quantity in possession
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Possession quantity is less than the specified value
lessEqual	Possession quantity is less than or equal to the specified value
greater	Possession quantity is greater than the specified value
greaterEqual	Possession quantity is greater than or equal to the specified value
equal	Possession quantity is equal to the specified value
notEqual	Possession quantity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyBigItem(
    &inventory.VerifyBigItemRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        InventoryName: pointy.String("inventory-0001"),
        ItemName: pointy.String("item-0001"),
        VerifyType: pointy.String("less"),
        Count: 10,
        MultiplyValueSpecifyingQuantity: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyBigItemRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyBigItem(
        (new VerifyBigItemRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withInventoryName("inventory-0001")
            ->withItemName("item-0001")
            ->withVerifyType("less")
            ->withCount(10)
            ->withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyBigItemRequest;
import io.gs2.inventory.result.VerifyBigItemResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyBigItemResult result = client.verifyBigItem(
        new VerifyBigItemRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyBigItemRequest;
using Gs2.Gs2Inventory.Result.VerifyBigItemResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyBigItemResult> asyncResult = null;
yield return client.VerifyBigItem(
    new Gs2.Gs2Inventory.Request.VerifyBigItemRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithInventoryName("inventory-0001")
        .WithItemName("item-0001")
        .WithVerifyType("less")
        .WithCount(10)
        .WithMultiplyValueSpecifyingQuantity(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyBigItem(
        new Gs2Inventory.VerifyBigItemRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_big_item(
        inventory.VerifyBigItemRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_inventory_name('inventory-0001')
            .with_item_name('item-0001')
            .with_verify_type('less')
            .with_count(10)
            .with_multiply_value_specifying_quantity(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_big_item({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_big_item_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

verifyBigItemByUserId

Verify possession quantity of big items by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
inventoryName	string	✓		~ 128 chars	Big Inventory Model Name
itemName	string	✓		~ 128 chars	Big Item Model Name
verifyType	enum { “less”, “lessEqual”, “greater”, “greaterEqual”, “equal”, “notEqual” }	✓		~ 128 chars	Type of verification
count	string	✓		~ 1024 chars	Quantity in possession
multiplyValueSpecifyingQuantity	bool	✓	true		Whether to multiply the value used for verification when specifying the quantity
timeOffsetToken	string			~ 1024 chars	Time offset token

Definition of enumeration type to be specified for verifyType

Enumerator String Definition	Description
less	Possession quantity is less than the specified value
lessEqual	Possession quantity is less than or equal to the specified value
greater	Possession quantity is greater than the specified value
greaterEqual	Possession quantity is greater than or equal to the specified value
equal	Possession quantity is equal to the specified value
notEqual	Possession quantity is not equal to the specified value

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyBigItemByUserId(
    &inventory.VerifyBigItemByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        InventoryName: pointy.String("inventory-0001"),
        ItemName: pointy.String("item-0001"),
        VerifyType: pointy.String("less"),
        Count: 10,
        MultiplyValueSpecifyingQuantity: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyBigItemByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyBigItemByUserId(
        (new VerifyBigItemByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withInventoryName("inventory-0001")
            ->withItemName("item-0001")
            ->withVerifyType("less")
            ->withCount(10)
            ->withMultiplyValueSpecifyingQuantity(null)
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyBigItemByUserIdRequest;
import io.gs2.inventory.result.VerifyBigItemByUserIdResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyBigItemByUserIdResult result = client.verifyBigItemByUserId(
        new VerifyBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyBigItemByUserIdRequest;
using Gs2.Gs2Inventory.Result.VerifyBigItemByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyBigItemByUserIdResult> asyncResult = null;
yield return client.VerifyBigItemByUserId(
    new Gs2.Gs2Inventory.Request.VerifyBigItemByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithInventoryName("inventory-0001")
        .WithItemName("item-0001")
        .WithVerifyType("less")
        .WithCount(10)
        .WithMultiplyValueSpecifyingQuantity(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyBigItemByUserId(
        new Gs2Inventory.VerifyBigItemByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withInventoryName("inventory-0001")
            .withItemName("item-0001")
            .withVerifyType("less")
            .withCount(10)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_big_item_by_user_id(
        inventory.VerifyBigItemByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_inventory_name('inventory-0001')
            .with_item_name('item-0001')
            .with_verify_type('less')
            .with_count(10)
            .with_multiply_value_specifying_quantity(None)
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_big_item_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('inventory')

api_result_handler = client.verify_big_item_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    inventoryName="inventory-0001",
    itemName="item-0001",
    verifyType="less",
    count=10,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

acquireBigItemByStampSheet

Execute acquisition of big items as acquire action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	BigItem	Quantity of big items after addition

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.AcquireBigItemByStampSheet(
    &inventory.AcquireBigItemByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\AcquireBigItemByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acquireBigItemByStampSheet(
        (new AcquireBigItemByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.AcquireBigItemByStampSheetRequest;
import io.gs2.inventory.result.AcquireBigItemByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    AcquireBigItemByStampSheetResult result = client.acquireBigItemByStampSheet(
        new AcquireBigItemByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    BigItem item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.AcquireBigItemByStampSheetRequest;
using Gs2.Gs2Inventory.Result.AcquireBigItemByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.AcquireBigItemByStampSheetResult> asyncResult = null;
yield return client.AcquireBigItemByStampSheet(
    new Gs2.Gs2Inventory.Request.AcquireBigItemByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.acquireBigItemByStampSheet(
        new Gs2Inventory.AcquireBigItemByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.acquire_big_item_by_stamp_sheet(
        inventory.AcquireBigItemByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.acquire_big_item_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.acquire_big_item_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

consumeBigItemByStampTask

Execute consumption of big items as consume action

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Consume Action
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	BigItem	Quantity of big items held per post-consumption expiration date
newContextStack	string	Request of context in which consume action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.ConsumeBigItemByStampTask(
    &inventory.ConsumeBigItemByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\ConsumeBigItemByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->consumeBigItemByStampTask(
        (new ConsumeBigItemByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.ConsumeBigItemByStampTaskRequest;
import io.gs2.inventory.result.ConsumeBigItemByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    ConsumeBigItemByStampTaskResult result = client.consumeBigItemByStampTask(
        new ConsumeBigItemByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    BigItem item = result.getItem();
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.ConsumeBigItemByStampTaskRequest;
using Gs2.Gs2Inventory.Result.ConsumeBigItemByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.ConsumeBigItemByStampTaskResult> asyncResult = null;
yield return client.ConsumeBigItemByStampTask(
    new Gs2.Gs2Inventory.Request.ConsumeBigItemByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.consumeBigItemByStampTask(
        new Gs2Inventory.ConsumeBigItemByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.consume_big_item_by_stamp_task(
        inventory.ConsumeBigItemByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    item = result.item
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.consume_big_item_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.consume_big_item_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;
newContextStack = result.newContextStack;

setBigItemByStampSheet

Execute setting of big items as acquire action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	BigItem	Quantity of big items after addition

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.SetBigItemByStampSheet(
    &inventory.SetBigItemByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-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\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\SetBigItemByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->setBigItemByStampSheet(
        (new SetBigItemByStampSheetRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.SetBigItemByStampSheetRequest;
import io.gs2.inventory.result.SetBigItemByStampSheetResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    SetBigItemByStampSheetResult result = client.setBigItemByStampSheet(
        new SetBigItemByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    BigItem item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.SetBigItemByStampSheetRequest;
using Gs2.Gs2Inventory.Result.SetBigItemByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.SetBigItemByStampSheetResult> asyncResult = null;
yield return client.SetBigItemByStampSheet(
    new Gs2.Gs2Inventory.Request.SetBigItemByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.setBigItemByStampSheet(
        new Gs2Inventory.SetBigItemByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.set_big_item_by_stamp_sheet(
        inventory.SetBigItemByStampSheetRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.set_big_item_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('inventory')

api_result_handler = client.set_big_item_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

verifyBigItemByStampTask

Execute verification of big items as verify action

Request

	Type	Condition	Require	Default	Limitation	Description
stampTask	string		✓		~ 5242880 chars	Verify Action
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
newContextStack	string	Request of context in which verify action execution results are recorded

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/inventory"
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 := inventory.Gs2InventoryRestClient{
    Session: &session,
}
result, err := client.VerifyBigItemByStampTask(
    &inventory.VerifyBigItemByStampTaskRequest {
        StampTask: pointy.String("stampTask"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
newContextStack := result.NewContextStack

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Inventory\Gs2InventoryRestClient;
use Gs2\Inventory\Request\VerifyBigItemByStampTaskRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->verifyBigItemByStampTask(
        (new VerifyBigItemByStampTaskRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $newContextStack = $result->getNewContextStack();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.inventory.rest.Gs2InventoryRestClient;
import io.gs2.inventory.request.VerifyBigItemByStampTaskRequest;
import io.gs2.inventory.result.VerifyBigItemByStampTaskResult;

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
session.connect();
Gs2InventoryRestClient client = new Gs2InventoryRestClient(session);

try {
    VerifyBigItemByStampTaskResult result = client.verifyBigItemByStampTask(
        new VerifyBigItemByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Inventory.Gs2InventoryRestClient;
using Gs2.Gs2Inventory.Request.VerifyBigItemByStampTaskRequest;
using Gs2.Gs2Inventory.Result.VerifyBigItemByStampTaskResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2InventoryRestClient(session);

AsyncResult<Gs2.Gs2Inventory.Result.VerifyBigItemByStampTaskResult> asyncResult = null;
yield return client.VerifyBigItemByStampTask(
    new Gs2.Gs2Inventory.Request.VerifyBigItemByStampTaskRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var newContextStack = result.NewContextStack;

import Gs2Core from '@/gs2/core';
import * as Gs2Inventory from '@/gs2/inventory';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Inventory.Gs2InventoryRestClient(session);

try {
    const result = await client.verifyBigItemByStampTask(
        new Gs2Inventory.VerifyBigItemByStampTaskRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import inventory

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = inventory.Gs2InventoryRestClient(session)

try:
    result = client.verify_big_item_by_stamp_task(
        inventory.VerifyBigItemByStampTaskRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('inventory')

api_result = client.verify_big_item_by_stamp_task({
    stampTask="stampTask",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('inventory')

api_result_handler = client.verify_big_item_by_stamp_task_async({
    stampTask="stampTask",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
newContextStack = result.newContextStack;