GS2-Distributor SDK API Reference

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

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

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

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

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

from gs2 import core
from gs2 import distributor

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

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

client = gs2('distributor')

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

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

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

client = gs2('distributor')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName("namespace-0001")
            ->withDescription(null)
            ->withTransactionSetting(null)
            ->withAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
            ->withAutoRunStampSheetNotification(null)
            ->withAutoRunTransactionNotification(null)
            ->withLogSetting((new \Gs2\Distributor\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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.CreateNamespaceRequest;
import io.gs2.distributor.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(null)
            .withAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
            .withAutoRunStampSheetNotification(null)
            .withAutoRunTransactionNotification(null)
            .withLogSetting(new io.gs2.distributor.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Distributor.Request.CreateNamespaceRequest()
        .WithName("namespace-0001")
        .WithDescription(null)
        .WithTransactionSetting(null)
        .WithAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
        .WithAutoRunStampSheetNotification(null)
        .WithAutoRunTransactionNotification(null)
        .WithLogSetting(new Gs2.Gs2Distributor.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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.createNamespace(
        new Gs2Distributor.CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(null)
            .withAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
            .withAutoRunStampSheetNotification(null)
            .withAutoRunTransactionNotification(null)
            .withLogSetting(new Gs2Distributor.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 distributor

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

try:
    result = client.create_namespace(
        distributor.CreateNamespaceRequest()
            .with_name('namespace-0001')
            .with_description(None)
            .with_transaction_setting(None)
            .with_assume_user_id('grn:gs2::YourOwnerId:identifier:user:user-0001')
            .with_auto_run_stamp_sheet_notification(None)
            .with_auto_run_transaction_notification(None)
            .with_log_setting(
                distributor.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('distributor')

api_result = client.create_namespace({
    name="namespace-0001",
    description=nil,
    transactionSetting=nil,
    assumeUserId="grn:gs2::YourOwnerId:identifier:user:user-0001",
    autoRunStampSheetNotification=nil,
    autoRunTransactionNotification=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.create_namespace_async({
    name="namespace-0001",
    description=nil,
    transactionSetting=nil,
    assumeUserId="grn:gs2::YourOwnerId:identifier:user:user-0001",
    autoRunStampSheetNotification=nil,
    autoRunTransactionNotification=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
    },
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetNamespaceStatusRequest;

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

$session->open();

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

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

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

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

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

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

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

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

from gs2 import core
from gs2 import distributor

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

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

client = gs2('distributor')

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

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

result = api_result.result
status = result.status;

client = gs2('distributor')

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

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

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

result = api_result.result
status = result.status;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetNamespaceRequest;

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

$session->open();

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

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

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

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

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

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

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

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

from gs2 import core
from gs2 import distributor

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

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

client = gs2('distributor')

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

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

result = api_result.result
item = result.item;

client = gs2('distributor')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName("namespace-0001")
            ->withDescription("description1")
            ->withTransactionSetting(null)
            ->withAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
            ->withAutoRunStampSheetNotification(null)
            ->withAutoRunTransactionNotification(null)
            ->withLogSetting(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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.UpdateNamespaceRequest;
import io.gs2.distributor.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(null)
            .withAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
            .withAutoRunStampSheetNotification(null)
            .withAutoRunTransactionNotification(null)
            .withLogSetting(null)
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Distributor.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace-0001")
        .WithDescription("description1")
        .WithTransactionSetting(null)
        .WithAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
        .WithAutoRunStampSheetNotification(null)
        .WithAutoRunTransactionNotification(null)
        .WithLogSetting(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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.updateNamespace(
        new Gs2Distributor.UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(null)
            .withAssumeUserId("grn:gs2::YourOwnerId:identifier:user:user-0001")
            .withAutoRunStampSheetNotification(null)
            .withAutoRunTransactionNotification(null)
            .withLogSetting(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.update_namespace(
        distributor.UpdateNamespaceRequest()
            .with_namespace_name('namespace-0001')
            .with_description('description1')
            .with_transaction_setting(None)
            .with_assume_user_id('grn:gs2::YourOwnerId:identifier:user:user-0001')
            .with_auto_run_stamp_sheet_notification(None)
            .with_auto_run_transaction_notification(None)
            .with_log_setting(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.update_namespace({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting=nil,
    assumeUserId="grn:gs2::YourOwnerId:identifier:user:user-0001",
    autoRunStampSheetNotification=nil,
    autoRunTransactionNotification=nil,
    logSetting=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting=nil,
    assumeUserId="grn:gs2::YourOwnerId:identifier:user:user-0001",
    autoRunStampSheetNotification=nil,
    autoRunTransactionNotification=nil,
    logSetting=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\DeleteNamespaceRequest;

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

$session->open();

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

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

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

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

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

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

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

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

from gs2 import core
from gs2 import distributor

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

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

client = gs2('distributor')

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

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

result = api_result.result
item = result.item;

client = gs2('distributor')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetServiceVersionRequest;

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

$session->open();

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

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

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

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

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

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

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

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

from gs2 import core
from gs2 import distributor

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

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

client = gs2('distributor')

api_result = client.get_service_version({
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.get_service_version_async({
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\DistributeRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->distribute(
        (new DistributeRequest())
            ->withNamespaceName("namespace-0001")
            ->withDistributorName("distributor-0001")
            ->withUserId("user-0001")
            ->withDistributeResource((new DistributeResource())
                ->withAction("Gs2Money:DepositWallet")
                ->withRequest("{}")
            )
            ->withTimeOffsetToken(null)
    );
    $distributeResource = $result->getDistributeResource();
    $inboxNamespaceId = $result->getInboxNamespaceId();
    $result = $result->getResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.DistributeRequest;
import io.gs2.distributor.result.DistributeResult;

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

try {
    DistributeResult result = client.distribute(
        new DistributeRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-0001")
            .withUserId("user-0001")
            .withDistributeResource(new DistributeResource()
                .withAction("Gs2Money:DepositWallet")
                .withRequest("{}")
            )
            .withTimeOffsetToken(null)
    );
    DistributeResource distributeResource = result.getDistributeResource();
    String inboxNamespaceId = result.getInboxNamespaceId();
    String result = result.getResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.DistributeResult> asyncResult = null;
yield return client.Distribute(
    new Gs2.Gs2Distributor.Request.DistributeRequest()
        .WithNamespaceName("namespace-0001")
        .WithDistributorName("distributor-0001")
        .WithUserId("user-0001")
        .WithDistributeResource(new Gs2.Gs2Distributor.Model.DistributeResource()
            .WithAction("Gs2Money:DepositWallet")
            .WithRequest("{}")
        )
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var distributeResource = result.DistributeResource;
var inboxNamespaceId = result.InboxNamespaceId;
var result = result.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.distribute(
        new Gs2Distributor.DistributeRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-0001")
            .withUserId("user-0001")
            .withDistributeResource(new Gs2Distributor.model.DistributeResource()
                .withAction("Gs2Money:DepositWallet")
                .withRequest("{}")
            )
            .withTimeOffsetToken(null)
    );
    const distributeResource = result.getDistributeResource();
    const inboxNamespaceId = result.getInboxNamespaceId();
    const result = result.getResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.distribute(
        distributor.DistributeRequest()
            .with_namespace_name('namespace-0001')
            .with_distributor_name('distributor-0001')
            .with_user_id('user-0001')
            .with_distribute_resource(distributor.DistributeResource()
                .with_action('Gs2Money:DepositWallet')
                .with_request('{}')
            )
            .with_time_offset_token(None)
    )
    distribute_resource = result.distribute_resource
    inbox_namespace_id = result.inbox_namespace_id
    result = result.result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.distribute({
    namespaceName="namespace-0001",
    distributorName="distributor-0001",
    userId="user-0001",
    distributeResource={
        action="Gs2Money:DepositWallet",
        request="{}",
    },
    timeOffsetToken=nil,
})

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

result = api_result.result
distributeResource = result.distributeResource;
inboxNamespaceId = result.inboxNamespaceId;
result = result.result;

client = gs2('distributor')

api_result_handler = client.distribute_async({
    namespaceName="namespace-0001",
    distributorName="distributor-0001",
    userId="user-0001",
    distributeResource={
        action="Gs2Money:DepositWallet",
        request="{}",
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result
distributeResource = result.distributeResource;
inboxNamespaceId = result.inboxNamespaceId;
result = result.result;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\DistributeWithoutOverflowProcessRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->distributeWithoutOverflowProcess(
        (new DistributeWithoutOverflowProcessRequest())
            ->withUserId("user-0001")
            ->withDistributeResource((new DistributeResource())
                ->withAction("Gs2Money:DepositWallet")
                ->withRequest("{}")
            )
            ->withTimeOffsetToken(null)
    );
    $distributeResource = $result->getDistributeResource();
    $result = $result->getResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.DistributeWithoutOverflowProcessRequest;
import io.gs2.distributor.result.DistributeWithoutOverflowProcessResult;

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

try {
    DistributeWithoutOverflowProcessResult result = client.distributeWithoutOverflowProcess(
        new DistributeWithoutOverflowProcessRequest()
            .withUserId("user-0001")
            .withDistributeResource(new DistributeResource()
                .withAction("Gs2Money:DepositWallet")
                .withRequest("{}")
            )
            .withTimeOffsetToken(null)
    );
    DistributeResource distributeResource = result.getDistributeResource();
    String result = result.getResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.DistributeWithoutOverflowProcessResult> asyncResult = null;
yield return client.DistributeWithoutOverflowProcess(
    new Gs2.Gs2Distributor.Request.DistributeWithoutOverflowProcessRequest()
        .WithUserId("user-0001")
        .WithDistributeResource(new Gs2.Gs2Distributor.Model.DistributeResource()
            .WithAction("Gs2Money:DepositWallet")
            .WithRequest("{}")
        )
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var distributeResource = result.DistributeResource;
var result = result.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.distributeWithoutOverflowProcess(
        new Gs2Distributor.DistributeWithoutOverflowProcessRequest()
            .withUserId("user-0001")
            .withDistributeResource(new Gs2Distributor.model.DistributeResource()
                .withAction("Gs2Money:DepositWallet")
                .withRequest("{}")
            )
            .withTimeOffsetToken(null)
    );
    const distributeResource = result.getDistributeResource();
    const result = result.getResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.distribute_without_overflow_process(
        distributor.DistributeWithoutOverflowProcessRequest()
            .with_user_id('user-0001')
            .with_distribute_resource(distributor.DistributeResource()
                .with_action('Gs2Money:DepositWallet')
                .with_request('{}')
            )
            .with_time_offset_token(None)
    )
    distribute_resource = result.distribute_resource
    result = result.result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.distribute_without_overflow_process({
    userId="user-0001",
    distributeResource={
        action="Gs2Money:DepositWallet",
        request="{}",
    },
    timeOffsetToken=nil,
})

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

result = api_result.result
distributeResource = result.distributeResource;
result = result.result;

client = gs2('distributor')

api_result_handler = client.distribute_without_overflow_process_async({
    userId="user-0001",
    distributeResource={
        action="Gs2Money:DepositWallet",
        request="{}",
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result
distributeResource = result.distributeResource;
result = result.result;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\RunVerifyTaskRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->runVerifyTask(
        (new RunVerifyTaskRequest())
            ->withNamespaceName("namespace-0001")
            ->withVerifyTask("stampTask")
            ->withKeyId("key-0001")
    );
    $contextStack = $result->getContextStack();
    $statusCode = $result->getStatusCode();
    $result = $result->getResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.RunVerifyTaskRequest;
import io.gs2.distributor.result.RunVerifyTaskResult;

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

try {
    RunVerifyTaskResult result = client.runVerifyTask(
        new RunVerifyTaskRequest()
            .withNamespaceName("namespace-0001")
            .withVerifyTask("stampTask")
            .withKeyId("key-0001")
    );
    String contextStack = result.getContextStack();
    int statusCode = result.getStatusCode();
    String result = result.getResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.RunVerifyTaskResult> asyncResult = null;
yield return client.RunVerifyTask(
    new Gs2.Gs2Distributor.Request.RunVerifyTaskRequest()
        .WithNamespaceName("namespace-0001")
        .WithVerifyTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var contextStack = result.ContextStack;
var statusCode = result.StatusCode;
var result = result.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.runVerifyTask(
        new Gs2Distributor.RunVerifyTaskRequest()
            .withNamespaceName("namespace-0001")
            .withVerifyTask("stampTask")
            .withKeyId("key-0001")
    );
    const contextStack = result.getContextStack();
    const statusCode = result.getStatusCode();
    const result = result.getResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.run_verify_task(
        distributor.RunVerifyTaskRequest()
            .with_namespace_name('namespace-0001')
            .with_verify_task('stampTask')
            .with_key_id('key-0001')
    )
    context_stack = result.context_stack
    status_code = result.status_code
    result = result.result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.run_verify_task({
    namespaceName="namespace-0001",
    verifyTask="stampTask",
    keyId="key-0001",
})

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

result = api_result.result
contextStack = result.contextStack;
statusCode = result.statusCode;
result = result.result;

client = gs2('distributor')

api_result_handler = client.run_verify_task_async({
    namespaceName="namespace-0001",
    verifyTask="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['errorMessage'])
end

result = api_result.result
contextStack = result.contextStack;
statusCode = result.statusCode;
result = result.result;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\RunStampSheetExpressRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->runStampSheetExpress(
        (new RunStampSheetExpressRequest())
            ->withNamespaceName("namespace-0001")
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $verifyTaskResultCodes = $result->getVerifyTaskResultCodes();
    $verifyTaskResults = $result->getVerifyTaskResults();
    $taskResultCodes = $result->getTaskResultCodes();
    $taskResults = $result->getTaskResults();
    $sheetResultCode = $result->getSheetResultCode();
    $sheetResult = $result->getSheetResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.RunStampSheetExpressRequest;
import io.gs2.distributor.result.RunStampSheetExpressResult;

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

try {
    RunStampSheetExpressResult result = client.runStampSheetExpress(
        new RunStampSheetExpressRequest()
            .withNamespaceName("namespace-0001")
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    List<int> verifyTaskResultCodes = result.getVerifyTaskResultCodes();
    List<String> verifyTaskResults = result.getVerifyTaskResults();
    List<int> taskResultCodes = result.getTaskResultCodes();
    List<String> taskResults = result.getTaskResults();
    int sheetResultCode = result.getSheetResultCode();
    String sheetResult = result.getSheetResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.RunStampSheetExpressResult> asyncResult = null;
yield return client.RunStampSheetExpress(
    new Gs2.Gs2Distributor.Request.RunStampSheetExpressRequest()
        .WithNamespaceName("namespace-0001")
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var verifyTaskResultCodes = result.VerifyTaskResultCodes;
var verifyTaskResults = result.VerifyTaskResults;
var taskResultCodes = result.TaskResultCodes;
var taskResults = result.TaskResults;
var sheetResultCode = result.SheetResultCode;
var sheetResult = result.SheetResult;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.runStampSheetExpress(
        new Gs2Distributor.RunStampSheetExpressRequest()
            .withNamespaceName("namespace-0001")
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const verifyTaskResultCodes = result.getVerifyTaskResultCodes();
    const verifyTaskResults = result.getVerifyTaskResults();
    const taskResultCodes = result.getTaskResultCodes();
    const taskResults = result.getTaskResults();
    const sheetResultCode = result.getSheetResultCode();
    const sheetResult = result.getSheetResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.run_stamp_sheet_express(
        distributor.RunStampSheetExpressRequest()
            .with_namespace_name('namespace-0001')
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    verify_task_result_codes = result.verify_task_result_codes
    verify_task_results = result.verify_task_results
    task_result_codes = result.task_result_codes
    task_results = result.task_results
    sheet_result_code = result.sheet_result_code
    sheet_result = result.sheet_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.run_stamp_sheet_express({
    namespaceName="namespace-0001",
    stampSheet="stampSheet",
    keyId="key-0001",
})

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

result = api_result.result
verifyTaskResultCodes = result.verifyTaskResultCodes;
verifyTaskResults = result.verifyTaskResults;
taskResultCodes = result.taskResultCodes;
taskResults = result.taskResults;
sheetResultCode = result.sheetResultCode;
sheetResult = result.sheetResult;

client = gs2('distributor')

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

result = api_result.result
verifyTaskResultCodes = result.verifyTaskResultCodes;
verifyTaskResults = result.verifyTaskResults;
taskResultCodes = result.taskResultCodes;
taskResults = result.taskResults;
sheetResultCode = result.sheetResultCode;
sheetResult = result.sheetResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\RunVerifyTaskWithoutNamespaceRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->runVerifyTaskWithoutNamespace(
        (new RunVerifyTaskWithoutNamespaceRequest())
            ->withVerifyTask("stampTask")
            ->withKeyId("key-0001")
    );
    $contextStack = $result->getContextStack();
    $statusCode = $result->getStatusCode();
    $result = $result->getResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.RunVerifyTaskWithoutNamespaceRequest;
import io.gs2.distributor.result.RunVerifyTaskWithoutNamespaceResult;

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

try {
    RunVerifyTaskWithoutNamespaceResult result = client.runVerifyTaskWithoutNamespace(
        new RunVerifyTaskWithoutNamespaceRequest()
            .withVerifyTask("stampTask")
            .withKeyId("key-0001")
    );
    String contextStack = result.getContextStack();
    int statusCode = result.getStatusCode();
    String result = result.getResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.RunVerifyTaskWithoutNamespaceResult> asyncResult = null;
yield return client.RunVerifyTaskWithoutNamespace(
    new Gs2.Gs2Distributor.Request.RunVerifyTaskWithoutNamespaceRequest()
        .WithVerifyTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var contextStack = result.ContextStack;
var statusCode = result.StatusCode;
var result = result.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.runVerifyTaskWithoutNamespace(
        new Gs2Distributor.RunVerifyTaskWithoutNamespaceRequest()
            .withVerifyTask("stampTask")
            .withKeyId("key-0001")
    );
    const contextStack = result.getContextStack();
    const statusCode = result.getStatusCode();
    const result = result.getResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.run_verify_task_without_namespace(
        distributor.RunVerifyTaskWithoutNamespaceRequest()
            .with_verify_task('stampTask')
            .with_key_id('key-0001')
    )
    context_stack = result.context_stack
    status_code = result.status_code
    result = result.result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.run_verify_task_without_namespace({
    verifyTask="stampTask",
    keyId="key-0001",
})

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

result = api_result.result
contextStack = result.contextStack;
statusCode = result.statusCode;
result = result.result;

client = gs2('distributor')

api_result_handler = client.run_verify_task_without_namespace_async({
    verifyTask="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['errorMessage'])
end

result = api_result.result
contextStack = result.contextStack;
statusCode = result.statusCode;
result = result.result;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\RunStampTaskWithoutNamespaceRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->runStampTaskWithoutNamespace(
        (new RunStampTaskWithoutNamespaceRequest())
            ->withStampTask("stampTask")
            ->withKeyId("key-0001")
    );
    $contextStack = $result->getContextStack();
    $statusCode = $result->getStatusCode();
    $result = $result->getResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.RunStampTaskWithoutNamespaceRequest;
import io.gs2.distributor.result.RunStampTaskWithoutNamespaceResult;

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

try {
    RunStampTaskWithoutNamespaceResult result = client.runStampTaskWithoutNamespace(
        new RunStampTaskWithoutNamespaceRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    String contextStack = result.getContextStack();
    int statusCode = result.getStatusCode();
    String result = result.getResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.RunStampTaskWithoutNamespaceResult> asyncResult = null;
yield return client.RunStampTaskWithoutNamespace(
    new Gs2.Gs2Distributor.Request.RunStampTaskWithoutNamespaceRequest()
        .WithStampTask("stampTask")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var contextStack = result.ContextStack;
var statusCode = result.StatusCode;
var result = result.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.runStampTaskWithoutNamespace(
        new Gs2Distributor.RunStampTaskWithoutNamespaceRequest()
            .withStampTask("stampTask")
            .withKeyId("key-0001")
    );
    const contextStack = result.getContextStack();
    const statusCode = result.getStatusCode();
    const result = result.getResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.run_stamp_task_without_namespace(
        distributor.RunStampTaskWithoutNamespaceRequest()
            .with_stamp_task('stampTask')
            .with_key_id('key-0001')
    )
    context_stack = result.context_stack
    status_code = result.status_code
    result = result.result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.run_stamp_task_without_namespace({
    stampTask="stampTask",
    keyId="key-0001",
})

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

result = api_result.result
contextStack = result.contextStack;
statusCode = result.statusCode;
result = result.result;

client = gs2('distributor')

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

result = api_result.result
contextStack = result.contextStack;
statusCode = result.statusCode;
result = result.result;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\RunStampSheetWithoutNamespaceRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->runStampSheetWithoutNamespace(
        (new RunStampSheetWithoutNamespaceRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $statusCode = $result->getStatusCode();
    $result = $result->getResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.RunStampSheetWithoutNamespaceRequest;
import io.gs2.distributor.result.RunStampSheetWithoutNamespaceResult;

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

try {
    RunStampSheetWithoutNamespaceResult result = client.runStampSheetWithoutNamespace(
        new RunStampSheetWithoutNamespaceRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    int statusCode = result.getStatusCode();
    String result = result.getResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.RunStampSheetWithoutNamespaceResult> asyncResult = null;
yield return client.RunStampSheetWithoutNamespace(
    new Gs2.Gs2Distributor.Request.RunStampSheetWithoutNamespaceRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var statusCode = result.StatusCode;
var result = result.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.runStampSheetWithoutNamespace(
        new Gs2Distributor.RunStampSheetWithoutNamespaceRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const statusCode = result.getStatusCode();
    const result = result.getResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.run_stamp_sheet_without_namespace(
        distributor.RunStampSheetWithoutNamespaceRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    status_code = result.status_code
    result = result.result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

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

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

result = api_result.result
statusCode = result.statusCode;
result = result.result;

client = gs2('distributor')

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

result = api_result.result
statusCode = result.statusCode;
result = result.result;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\RunStampSheetExpressWithoutNamespaceRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->runStampSheetExpressWithoutNamespace(
        (new RunStampSheetExpressWithoutNamespaceRequest())
            ->withStampSheet("stampSheet")
            ->withKeyId("key-0001")
    );
    $verifyTaskResultCodes = $result->getVerifyTaskResultCodes();
    $verifyTaskResults = $result->getVerifyTaskResults();
    $taskResultCodes = $result->getTaskResultCodes();
    $taskResults = $result->getTaskResults();
    $sheetResultCode = $result->getSheetResultCode();
    $sheetResult = $result->getSheetResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.RunStampSheetExpressWithoutNamespaceRequest;
import io.gs2.distributor.result.RunStampSheetExpressWithoutNamespaceResult;

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

try {
    RunStampSheetExpressWithoutNamespaceResult result = client.runStampSheetExpressWithoutNamespace(
        new RunStampSheetExpressWithoutNamespaceRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    List<int> verifyTaskResultCodes = result.getVerifyTaskResultCodes();
    List<String> verifyTaskResults = result.getVerifyTaskResults();
    List<int> taskResultCodes = result.getTaskResultCodes();
    List<String> taskResults = result.getTaskResults();
    int sheetResultCode = result.getSheetResultCode();
    String sheetResult = result.getSheetResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.RunStampSheetExpressWithoutNamespaceResult> asyncResult = null;
yield return client.RunStampSheetExpressWithoutNamespace(
    new Gs2.Gs2Distributor.Request.RunStampSheetExpressWithoutNamespaceRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var verifyTaskResultCodes = result.VerifyTaskResultCodes;
var verifyTaskResults = result.VerifyTaskResults;
var taskResultCodes = result.TaskResultCodes;
var taskResults = result.TaskResults;
var sheetResultCode = result.SheetResultCode;
var sheetResult = result.SheetResult;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.runStampSheetExpressWithoutNamespace(
        new Gs2Distributor.RunStampSheetExpressWithoutNamespaceRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const verifyTaskResultCodes = result.getVerifyTaskResultCodes();
    const verifyTaskResults = result.getVerifyTaskResults();
    const taskResultCodes = result.getTaskResultCodes();
    const taskResults = result.getTaskResults();
    const sheetResultCode = result.getSheetResultCode();
    const sheetResult = result.getSheetResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.run_stamp_sheet_express_without_namespace(
        distributor.RunStampSheetExpressWithoutNamespaceRequest()
            .with_stamp_sheet('stampSheet')
            .with_key_id('key-0001')
    )
    verify_task_result_codes = result.verify_task_result_codes
    verify_task_results = result.verify_task_results
    task_result_codes = result.task_result_codes
    task_results = result.task_results
    sheet_result_code = result.sheet_result_code
    sheet_result = result.sheet_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

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

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

result = api_result.result
verifyTaskResultCodes = result.verifyTaskResultCodes;
verifyTaskResults = result.verifyTaskResults;
taskResultCodes = result.taskResultCodes;
taskResults = result.taskResults;
sheetResultCode = result.sheetResultCode;
sheetResult = result.sheetResult;

client = gs2('distributor')

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

result = api_result.result
verifyTaskResultCodes = result.verifyTaskResultCodes;
verifyTaskResults = result.verifyTaskResults;
taskResultCodes = result.taskResultCodes;
taskResults = result.taskResults;
sheetResultCode = result.sheetResultCode;
sheetResult = result.sheetResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\SetTransactionDefaultConfigRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->setTransactionDefaultConfig(
        (new SetTransactionDefaultConfigRequest())
            ->withAccessToken("accessToken-0001")
            ->withConfig([
                (new Config())
                    ->withKey("key-0001")
                    ->withValue("value-0001"),
                (new Config())
                    ->withKey("key-0002")
                    ->withValue("value-0002"),
            ])
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.SetTransactionDefaultConfigRequest;
import io.gs2.distributor.result.SetTransactionDefaultConfigResult;

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

try {
    SetTransactionDefaultConfigResult result = client.setTransactionDefaultConfig(
        new SetTransactionDefaultConfigRequest()
            .withAccessToken("accessToken-0001")
            .withConfig(Arrays.asList(
                new Config()
                    .withKey("key-0001")
                    .withValue("value-0001"),
                new Config()
                    .withKey("key-0002")
                    .withValue("value-0002")
            ))
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.SetTransactionDefaultConfigResult> asyncResult = null;
yield return client.SetTransactionDefaultConfig(
    new Gs2.Gs2Distributor.Request.SetTransactionDefaultConfigRequest()
        .WithAccessToken("accessToken-0001")
        .WithConfig(new Gs2.Gs2Distributor.Model.Config[] {
            new Gs2.Gs2Distributor.Model.Config()
                .WithKey("key-0001")
                .WithValue("value-0001"),
            new Gs2.Gs2Distributor.Model.Config()
                .WithKey("key-0002")
                .WithValue("value-0002"),
        }),
    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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.setTransactionDefaultConfig(
        new Gs2Distributor.SetTransactionDefaultConfigRequest()
            .withAccessToken("accessToken-0001")
            .withConfig([
                new Gs2Distributor.model.Config()
                    .withKey("key-0001")
                    .withValue("value-0001"),
                new Gs2Distributor.model.Config()
                    .withKey("key-0002")
                    .withValue("value-0002"),
            ])
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.set_transaction_default_config(
        distributor.SetTransactionDefaultConfigRequest()
            .with_access_token('accessToken-0001')
            .with_config([
                distributor.Config()
                    .with_key('key-0001')
                    .with_value('value-0001'),
                distributor.Config()
                    .with_key('key-0002')
                    .with_value('value-0002'),
            ])
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.set_transaction_default_config({
    accessToken="accessToken-0001",
    config={
        {
            key="key-0001",
            value="value-0001",
        },
        {
            key="key-0002",
            value="value-0002",
        }
    },
})

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

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('distributor')

api_result_handler = client.set_transaction_default_config_async({
    accessToken="accessToken-0001",
    config={
        {
            key="key-0001",
            value="value-0001",
        },
        {
            key="key-0002",
            value="value-0002",
        }
    },
})

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

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

result = api_result.result
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\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\SetTransactionDefaultConfigByUserIdRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->setTransactionDefaultConfigByUserId(
        (new SetTransactionDefaultConfigByUserIdRequest())
            ->withUserId("user-0001")
            ->withConfig([
                (new Config())
                    ->withKey("key-0001")
                    ->withValue("value-0001"),
                (new Config())
                    ->withKey("key-0002")
                    ->withValue("value-0002"),
            ])
            ->withTimeOffsetToken(null)
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.SetTransactionDefaultConfigByUserIdRequest;
import io.gs2.distributor.result.SetTransactionDefaultConfigByUserIdResult;

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

try {
    SetTransactionDefaultConfigByUserIdResult result = client.setTransactionDefaultConfigByUserId(
        new SetTransactionDefaultConfigByUserIdRequest()
            .withUserId("user-0001")
            .withConfig(Arrays.asList(
                new Config()
                    .withKey("key-0001")
                    .withValue("value-0001"),
                new Config()
                    .withKey("key-0002")
                    .withValue("value-0002")
            ))
            .withTimeOffsetToken(null)
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.SetTransactionDefaultConfigByUserIdResult> asyncResult = null;
yield return client.SetTransactionDefaultConfigByUserId(
    new Gs2.Gs2Distributor.Request.SetTransactionDefaultConfigByUserIdRequest()
        .WithUserId("user-0001")
        .WithConfig(new Gs2.Gs2Distributor.Model.Config[] {
            new Gs2.Gs2Distributor.Model.Config()
                .WithKey("key-0001")
                .WithValue("value-0001"),
            new Gs2.Gs2Distributor.Model.Config()
                .WithKey("key-0002")
                .WithValue("value-0002"),
        })
        .WithTimeOffsetToken(null),
    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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.setTransactionDefaultConfigByUserId(
        new Gs2Distributor.SetTransactionDefaultConfigByUserIdRequest()
            .withUserId("user-0001")
            .withConfig([
                new Gs2Distributor.model.Config()
                    .withKey("key-0001")
                    .withValue("value-0001"),
                new Gs2Distributor.model.Config()
                    .withKey("key-0002")
                    .withValue("value-0002"),
            ])
            .withTimeOffsetToken(null)
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.set_transaction_default_config_by_user_id(
        distributor.SetTransactionDefaultConfigByUserIdRequest()
            .with_user_id('user-0001')
            .with_config([
                distributor.Config()
                    .with_key('key-0001')
                    .with_value('value-0001'),
                distributor.Config()
                    .with_key('key-0002')
                    .with_value('value-0002'),
            ])
            .with_time_offset_token(None)
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.set_transaction_default_config_by_user_id({
    userId="user-0001",
    config={
        {
            key="key-0001",
            value="value-0001",
        },
        {
            key="key-0002",
            value="value-0002",
        }
    },
    timeOffsetToken=nil,
})

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

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('distributor')

api_result_handler = client.set_transaction_default_config_by_user_id_async({
    userId="user-0001",
    config={
        {
            key="key-0001",
            value="value-0001",
        },
        {
            key="key-0002",
            value="value-0002",
        }
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result
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\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\FreezeMasterDataRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->freezeMasterData(
        (new FreezeMasterDataRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.FreezeMasterDataRequest;
import io.gs2.distributor.result.FreezeMasterDataResult;

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

try {
    FreezeMasterDataResult result = client.freezeMasterData(
        new FreezeMasterDataRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.FreezeMasterDataResult> asyncResult = null;
yield return client.FreezeMasterData(
    new Gs2.Gs2Distributor.Request.FreezeMasterDataRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.freezeMasterData(
        new Gs2Distributor.FreezeMasterDataRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.freeze_master_data(
        distributor.FreezeMasterDataRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

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

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

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('distributor')

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

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

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

result = api_result.result
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\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\FreezeMasterDataByUserIdRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->freezeMasterDataByUserId(
        (new FreezeMasterDataByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.FreezeMasterDataByUserIdRequest;
import io.gs2.distributor.result.FreezeMasterDataByUserIdResult;

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

try {
    FreezeMasterDataByUserIdResult result = client.freezeMasterDataByUserId(
        new FreezeMasterDataByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.FreezeMasterDataByUserIdResult> asyncResult = null;
yield return client.FreezeMasterDataByUserId(
    new Gs2.Gs2Distributor.Request.FreezeMasterDataByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.freezeMasterDataByUserId(
        new Gs2Distributor.FreezeMasterDataByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.freeze_master_data_by_user_id(
        distributor.FreezeMasterDataByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

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

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

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('distributor')

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

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

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

result = api_result.result
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\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\SignFreezeMasterDataTimestampRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->signFreezeMasterDataTimestamp(
        (new SignFreezeMasterDataTimestampRequest())
            ->withNamespaceName("namespace-0001")
            ->withTimestamp(10000)
            ->withKeyId("key-0001")
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.SignFreezeMasterDataTimestampRequest;
import io.gs2.distributor.result.SignFreezeMasterDataTimestampResult;

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

try {
    SignFreezeMasterDataTimestampResult result = client.signFreezeMasterDataTimestamp(
        new SignFreezeMasterDataTimestampRequest()
            .withNamespaceName("namespace-0001")
            .withTimestamp(10000L)
            .withKeyId("key-0001")
    );
    String body = result.getBody();
    String signature = result.getSignature();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.SignFreezeMasterDataTimestampResult> asyncResult = null;
yield return client.SignFreezeMasterDataTimestamp(
    new Gs2.Gs2Distributor.Request.SignFreezeMasterDataTimestampRequest()
        .WithNamespaceName("namespace-0001")
        .WithTimestamp(10000L)
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var body = result.Body;
var signature = result.Signature;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.signFreezeMasterDataTimestamp(
        new Gs2Distributor.SignFreezeMasterDataTimestampRequest()
            .withNamespaceName("namespace-0001")
            .withTimestamp(10000)
            .withKeyId("key-0001")
    );
    const body = result.getBody();
    const signature = result.getSignature();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.sign_freeze_master_data_timestamp(
        distributor.SignFreezeMasterDataTimestampRequest()
            .with_namespace_name('namespace-0001')
            .with_timestamp(10000)
            .with_key_id('key-0001')
    )
    body = result.body
    signature = result.signature
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.sign_freeze_master_data_timestamp({
    namespaceName="namespace-0001",
    timestamp=10000,
    keyId="key-0001",
})

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

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

client = gs2('distributor')

api_result_handler = client.sign_freeze_master_data_timestamp_async({
    namespaceName="namespace-0001",
    timestamp=10000,
    keyId="key-0001",
})

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

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

result = api_result.result
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\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\FreezeMasterDataBySignedTimestampRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->freezeMasterDataBySignedTimestamp(
        (new FreezeMasterDataBySignedTimestampRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withBody("body")
            ->withSignature("signature")
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.FreezeMasterDataBySignedTimestampRequest;
import io.gs2.distributor.result.FreezeMasterDataBySignedTimestampResult;

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

try {
    FreezeMasterDataBySignedTimestampResult result = client.freezeMasterDataBySignedTimestamp(
        new FreezeMasterDataBySignedTimestampRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withBody("body")
            .withSignature("signature")
            .withKeyId("key-0001")
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.FreezeMasterDataBySignedTimestampResult> asyncResult = null;
yield return client.FreezeMasterDataBySignedTimestamp(
    new Gs2.Gs2Distributor.Request.FreezeMasterDataBySignedTimestampRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithBody("body")
        .WithSignature("signature")
        .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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.freezeMasterDataBySignedTimestamp(
        new Gs2Distributor.FreezeMasterDataBySignedTimestampRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withBody("body")
            .withSignature("signature")
            .withKeyId("key-0001")
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.freeze_master_data_by_signed_timestamp(
        distributor.FreezeMasterDataBySignedTimestampRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_body('body')
            .with_signature('signature')
            .with_key_id('key-0001')
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.freeze_master_data_by_signed_timestamp({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    body="body",
    signature="signature",
    keyId="key-0001",
})

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

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('distributor')

api_result_handler = client.freeze_master_data_by_signed_timestamp_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    body="body",
    signature="signature",
    keyId="key-0001",
})

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

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

result = api_result.result
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\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\FreezeMasterDataByTimestampRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->freezeMasterDataByTimestamp(
        (new FreezeMasterDataByTimestampRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withTimestamp(10000)
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.FreezeMasterDataByTimestampRequest;
import io.gs2.distributor.result.FreezeMasterDataByTimestampResult;

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

try {
    FreezeMasterDataByTimestampResult result = client.freezeMasterDataByTimestamp(
        new FreezeMasterDataByTimestampRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTimestamp(10000L)
    );
    String newContextStack = result.getNewContextStack();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.FreezeMasterDataByTimestampResult> asyncResult = null;
yield return client.FreezeMasterDataByTimestamp(
    new Gs2.Gs2Distributor.Request.FreezeMasterDataByTimestampRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithTimestamp(10000L),
    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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.freezeMasterDataByTimestamp(
        new Gs2Distributor.FreezeMasterDataByTimestampRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTimestamp(10000)
    );
    const newContextStack = result.getNewContextStack();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.freeze_master_data_by_timestamp(
        distributor.FreezeMasterDataByTimestampRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_timestamp(10000)
    )
    new_context_stack = result.new_context_stack
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.freeze_master_data_by_timestamp({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    timestamp=10000,
})

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

result = api_result.result
newContextStack = result.newContextStack;

client = gs2('distributor')

api_result_handler = client.freeze_master_data_by_timestamp_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    timestamp=10000,
})

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

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

result = api_result.result
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\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\BatchExecuteApiRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->batchExecuteApi(
        (new BatchExecuteApiRequest())
            ->withRequestPayloads([
                (new BatchRequestPayload())
                    ->withService("inventory")
                    ->withMethod("describeSimpleItems")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"inventory-0001\", \"accessToken\": \"accessToken-0001\"}"),
                (new BatchRequestPayload())
                    ->withService("exchange")
                    ->withMethod("describeRateModels")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\"}"),
            ])
    );
    $results = $result->getResults();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.BatchExecuteApiRequest;
import io.gs2.distributor.result.BatchExecuteApiResult;

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

try {
    BatchExecuteApiResult result = client.batchExecuteApi(
        new BatchExecuteApiRequest()
            .withRequestPayloads(Arrays.asList(
                new BatchRequestPayload()
                    .withService("inventory")
                    .withMethod("describeSimpleItems")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"inventory-0001\", \"accessToken\": \"accessToken-0001\"}"),
                new BatchRequestPayload()
                    .withService("exchange")
                    .withMethod("describeRateModels")
                    .withRequest("{\"namespaceName\": \"namespace-0001\"}")
            ))
    );
    List<BatchResultPayload> results = result.getResults();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.BatchExecuteApiResult> asyncResult = null;
yield return client.BatchExecuteApi(
    new Gs2.Gs2Distributor.Request.BatchExecuteApiRequest()
        .WithRequestPayloads(new Gs2.Gs2Distributor.Model.BatchRequestPayload[] {
            new Gs2.Gs2Distributor.Model.BatchRequestPayload()
                .WithService("inventory")
                .WithMethod("describeSimpleItems")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"inventory-0001\", \"accessToken\": \"accessToken-0001\"}"),
            new Gs2.Gs2Distributor.Model.BatchRequestPayload()
                .WithService("exchange")
                .WithMethod("describeRateModels")
                .WithRequest("{\"namespaceName\": \"namespace-0001\"}"),
        }),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var results = result.Results;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.batchExecuteApi(
        new Gs2Distributor.BatchExecuteApiRequest()
            .withRequestPayloads([
                new Gs2Distributor.model.BatchRequestPayload()
                    .withService("inventory")
                    .withMethod("describeSimpleItems")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"inventory-0001\", \"accessToken\": \"accessToken-0001\"}"),
                new Gs2Distributor.model.BatchRequestPayload()
                    .withService("exchange")
                    .withMethod("describeRateModels")
                    .withRequest("{\"namespaceName\": \"namespace-0001\"}"),
            ])
    );
    const results = result.getResults();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.batch_execute_api(
        distributor.BatchExecuteApiRequest()
            .with_request_payloads([
                distributor.BatchRequestPayload()
                    .with_service('inventory')
                    .with_method('describeSimpleItems')
                    .with_request('{"namespaceName": "namespace-0001", "inventoryName": "inventory-0001", "accessToken": "accessToken-0001"}'),
                distributor.BatchRequestPayload()
                    .with_service('exchange')
                    .with_method('describeRateModels')
                    .with_request('{"namespaceName": "namespace-0001"}'),
            ])
    )
    results = result.results
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.batch_execute_api({
    requestPayloads={
        {
            service="inventory",
            method="describeSimpleItems",
            request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"inventory-0001\", \"accessToken\": \"accessToken-0001\"}",
        },
        {
            service="exchange",
            method="describeRateModels",
            request="{\"namespaceName\": \"namespace-0001\"}",
        }
    },
})

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

result = api_result.result
results = result.results;

client = gs2('distributor')

api_result_handler = client.batch_execute_api_async({
    requestPayloads={
        {
            service="inventory",
            method="describeSimpleItems",
            request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"inventory-0001\", \"accessToken\": \"accessToken-0001\"}",
        },
        {
            service="exchange",
            method="describeRateModels",
            request="{\"namespaceName\": \"namespace-0001\"}",
        }
    },
})

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

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

result = api_result.result
results = result.results;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\IfExpressionByUserIdRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->ifExpressionByUserId(
        (new IfExpressionByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withCondition((new VerifyAction())
                ->withAction("Gs2Inventory:VerifyItemSetByUserId")
                ->withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}")
            )
            ->withTrueActions([
                (new ConsumeAction())
                    ->withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"consumeCount\": 1}"),
            ])
            ->withFalseActions([
                (new ConsumeAction())
                    ->withAction("Gs2Inventory:ConsumeSimpleItemsByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"consumeCounts\": [{\"itemName\": \"item-0001\", \"count\": 1}]}"),
            ])
            ->withMultiplyValueSpecifyingQuantity(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $expressionResult = $result->getExpressionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.IfExpressionByUserIdRequest;
import io.gs2.distributor.result.IfExpressionByUserIdResult;

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

try {
    IfExpressionByUserIdResult result = client.ifExpressionByUserId(
        new IfExpressionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withCondition(new VerifyAction()
                .withAction("Gs2Inventory:VerifyItemSetByUserId")
                .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}")
            )
            .withTrueActions(Arrays.asList(
                new ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"consumeCount\": 1}")
            ))
            .withFalseActions(Arrays.asList(
                new ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeSimpleItemsByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"consumeCounts\": [{\"itemName\": \"item-0001\", \"count\": 1}]}")
            ))
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
    TransactionResult item = result.getItem();
    boolean expressionResult = result.getExpressionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.IfExpressionByUserIdResult> asyncResult = null;
yield return client.IfExpressionByUserId(
    new Gs2.Gs2Distributor.Request.IfExpressionByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithCondition(new Gs2.Core.Model.VerifyAction()
            .WithAction("Gs2Inventory:VerifyItemSetByUserId")
            .WithRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}")
        )
        .WithTrueActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Inventory:ConsumeItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"consumeCount\": 1}"),
        })
        .WithFalseActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Inventory:ConsumeSimpleItemsByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"consumeCounts\": [{\"itemName\": \"item-0001\", \"count\": 1}]}"),
        })
        .WithMultiplyValueSpecifyingQuantity(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var expressionResult = result.ExpressionResult;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.ifExpressionByUserId(
        new Gs2Distributor.IfExpressionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withCondition(new Gs2Distributor.model.VerifyAction()
                .withAction("Gs2Inventory:VerifyItemSetByUserId")
                .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}")
            )
            .withTrueActions([
                new Gs2Distributor.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"consumeCount\": 1}"),
            ])
            .withFalseActions([
                new Gs2Distributor.model.ConsumeAction()
                    .withAction("Gs2Inventory:ConsumeSimpleItemsByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"consumeCounts\": [{\"itemName\": \"item-0001\", \"count\": 1}]}"),
            ])
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const expressionResult = result.getExpressionResult();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.if_expression_by_user_id(
        distributor.IfExpressionByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_condition(distributor.VerifyAction()
                .with_action('Gs2Inventory:VerifyItemSetByUserId')
                .with_request('{"namespaceName": "namespace-0001", "userId": "user-0001", "inventoryName": "inventory-0001", "itemName": "item-0001", "verifyType": "greaterEqual", "count": 1}')
            )
            .with_true_actions([
                distributor.ConsumeAction()
                    .with_action('Gs2Inventory:ConsumeItemSetByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "userId": "user-0001", "inventoryName": "inventory-0001", "itemName": "item-0001", "consumeCount": 1}'),
            ])
            .with_false_actions([
                distributor.ConsumeAction()
                    .with_action('Gs2Inventory:ConsumeSimpleItemsByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "userId": "user-0001", "inventoryName": "inventory-0001", "consumeCounts": [{"itemName": "item-0001", "count": 1}]}'),
            ])
            .with_multiply_value_specifying_quantity(None)
            .with_time_offset_token(None)
    )
    item = result.item
    expression_result = result.expression_result
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.if_expression_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    condition={
        action="Gs2Inventory:VerifyItemSetByUserId",
        request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
    },
    trueActions={
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"consumeCount\": 1}",
        }
    },
    falseActions={
        {
            action="Gs2Inventory:ConsumeSimpleItemsByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"consumeCounts\": [{\"itemName\": \"item-0001\", \"count\": 1}]}",
        }
    },
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
expressionResult = result.expressionResult;

client = gs2('distributor')

api_result_handler = client.if_expression_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    condition={
        action="Gs2Inventory:VerifyItemSetByUserId",
        request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
    },
    trueActions={
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"consumeCount\": 1}",
        }
    },
    falseActions={
        {
            action="Gs2Inventory:ConsumeSimpleItemsByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"consumeCounts\": [{\"itemName\": \"item-0001\", \"count\": 1}]}",
        }
    },
    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['errorMessage'])
end

result = api_result.result
item = result.item;
expressionResult = result.expressionResult;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\AndExpressionByUserIdRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->andExpressionByUserId(
        (new AndExpressionByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withActions([
                (new VerifyAction())
                    ->withAction("Gs2Inventory:VerifyItemSetByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
                (new VerifyAction())
                    ->withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
            ])
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.AndExpressionByUserIdRequest;
import io.gs2.distributor.result.AndExpressionByUserIdResult;

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

try {
    AndExpressionByUserIdResult result = client.andExpressionByUserId(
        new AndExpressionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withActions(Arrays.asList(
                new VerifyAction()
                    .withAction("Gs2Inventory:VerifyItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
                new VerifyAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}")
            ))
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.AndExpressionByUserIdResult> asyncResult = null;
yield return client.AndExpressionByUserId(
    new Gs2.Gs2Distributor.Request.AndExpressionByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithActions(new Gs2.Core.Model.VerifyAction[] {
            new Gs2.Core.Model.VerifyAction()
                .WithAction("Gs2Inventory:VerifyItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
            new Gs2.Core.Model.VerifyAction()
                .WithAction("Gs2Inventory:ConsumeItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
        })
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.andExpressionByUserId(
        new Gs2Distributor.AndExpressionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withActions([
                new Gs2Distributor.model.VerifyAction()
                    .withAction("Gs2Inventory:VerifyItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
                new Gs2Distributor.model.VerifyAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
            ])
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.and_expression_by_user_id(
        distributor.AndExpressionByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_actions([
                distributor.VerifyAction()
                    .with_action('Gs2Inventory:VerifyItemSetByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "userId": "user-0001", "inventoryName": "inventory-0001", "itemName": "item-0001", "verifyType": "greaterEqual", "count": 1}'),
                distributor.VerifyAction()
                    .with_action('Gs2Inventory:ConsumeItemSetByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "userId": "user-0001", "inventoryName": "inventory-0001", "itemName": "item-0002", "verifyType": "greaterEqual", "count": 1}'),
            ])
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.and_expression_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    actions={
        {
            action="Gs2Inventory:VerifyItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        },
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        }
    },
    timeOffsetToken=nil,
})

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

result = api_result.result

client = gs2('distributor')

api_result_handler = client.and_expression_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    actions={
        {
            action="Gs2Inventory:VerifyItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        },
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        }
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\OrExpressionByUserIdRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->orExpressionByUserId(
        (new OrExpressionByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withActions([
                (new VerifyAction())
                    ->withAction("Gs2Inventory:VerifyItemSetByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
                (new VerifyAction())
                    ->withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
            ])
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.OrExpressionByUserIdRequest;
import io.gs2.distributor.result.OrExpressionByUserIdResult;

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

try {
    OrExpressionByUserIdResult result = client.orExpressionByUserId(
        new OrExpressionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withActions(Arrays.asList(
                new VerifyAction()
                    .withAction("Gs2Inventory:VerifyItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
                new VerifyAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}")
            ))
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.OrExpressionByUserIdResult> asyncResult = null;
yield return client.OrExpressionByUserId(
    new Gs2.Gs2Distributor.Request.OrExpressionByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithActions(new Gs2.Core.Model.VerifyAction[] {
            new Gs2.Core.Model.VerifyAction()
                .WithAction("Gs2Inventory:VerifyItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
            new Gs2.Core.Model.VerifyAction()
                .WithAction("Gs2Inventory:ConsumeItemSetByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
        })
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.orExpressionByUserId(
        new Gs2Distributor.OrExpressionByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withActions([
                new Gs2Distributor.model.VerifyAction()
                    .withAction("Gs2Inventory:VerifyItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
                new Gs2Distributor.model.VerifyAction()
                    .withAction("Gs2Inventory:ConsumeItemSetByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}"),
            ])
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.or_expression_by_user_id(
        distributor.OrExpressionByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_actions([
                distributor.VerifyAction()
                    .with_action('Gs2Inventory:VerifyItemSetByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "userId": "user-0001", "inventoryName": "inventory-0001", "itemName": "item-0001", "verifyType": "greaterEqual", "count": 1}'),
                distributor.VerifyAction()
                    .with_action('Gs2Inventory:ConsumeItemSetByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "userId": "user-0001", "inventoryName": "inventory-0001", "itemName": "item-0002", "verifyType": "greaterEqual", "count": 1}'),
            ])
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.or_expression_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    actions={
        {
            action="Gs2Inventory:VerifyItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        },
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        }
    },
    timeOffsetToken=nil,
})

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

result = api_result.result

client = gs2('distributor')

api_result_handler = client.or_expression_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    actions={
        {
            action="Gs2Inventory:VerifyItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0001\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        },
        {
            action="Gs2Inventory:ConsumeItemSetByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"userId\": \"user-0001\", \"inventoryName\": \"inventory-0001\", \"itemName\": \"item-0002\", \"verifyType\": \"greaterEqual\", \"count\": 1}",
        }
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetStampSheetResultRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->getStampSheetResult(
        (new GetStampSheetResultRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.GetStampSheetResultRequest;
import io.gs2.distributor.result.GetStampSheetResultResult;

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

try {
    GetStampSheetResultResult result = client.getStampSheetResult(
        new GetStampSheetResultRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
    );
    StampSheetResult item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.GetStampSheetResultResult> asyncResult = null;
yield return client.GetStampSheetResult(
    new Gs2.Gs2Distributor.Request.GetStampSheetResultRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec"),
    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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.getStampSheetResult(
        new Gs2Distributor.GetStampSheetResultRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.get_stamp_sheet_result(
        distributor.GetStampSheetResultRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_transaction_id('cc1985c3-54f0-4fc3-b295-dc30214284ec')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.get_stamp_sheet_result({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.get_stamp_sheet_result_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetStampSheetResultByUserIdRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->getStampSheetResultByUserId(
        (new GetStampSheetResultByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.GetStampSheetResultByUserIdRequest;
import io.gs2.distributor.result.GetStampSheetResultByUserIdResult;

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

try {
    GetStampSheetResultByUserIdResult result = client.getStampSheetResultByUserId(
        new GetStampSheetResultByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
            .withTimeOffsetToken(null)
    );
    StampSheetResult item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.GetStampSheetResultByUserIdResult> asyncResult = null;
yield return client.GetStampSheetResultByUserId(
    new Gs2.Gs2Distributor.Request.GetStampSheetResultByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
        .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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.getStampSheetResultByUserId(
        new Gs2Distributor.GetStampSheetResultByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.get_stamp_sheet_result_by_user_id(
        distributor.GetStampSheetResultByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_transaction_id('cc1985c3-54f0-4fc3-b295-dc30214284ec')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.get_stamp_sheet_result_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.get_stamp_sheet_result_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\RunTransactionRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->runTransaction(
        (new RunTransactionRequest())
            ->withOwnerId(null)
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTransaction("transaction...")
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.RunTransactionRequest;
import io.gs2.distributor.result.RunTransactionResult;

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

try {
    RunTransactionResult result = client.runTransaction(
        new RunTransactionRequest()
            .withOwnerId(null)
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTransaction("transaction...")
            .withTimeOffsetToken(null)
    );
    TransactionResult item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.RunTransactionResult> asyncResult = null;
yield return client.RunTransaction(
    new Gs2.Gs2Distributor.Request.RunTransactionRequest()
        .WithOwnerId(null)
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTransaction("transaction...")
        .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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.runTransaction(
        new Gs2Distributor.RunTransactionRequest()
            .withOwnerId(null)
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTransaction("transaction...")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.run_transaction(
        distributor.RunTransactionRequest()
            .with_owner_id(None)
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_transaction('transaction...')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.run_transaction({
    ownerId=nil,
    namespaceName="namespace-0001",
    userId="user-0001",
    transaction="transaction...",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.run_transaction_async({
    ownerId=nil,
    namespaceName="namespace-0001",
    userId="user-0001",
    transaction="transaction...",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetTransactionResultRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->getTransactionResult(
        (new GetTransactionResultRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.GetTransactionResultRequest;
import io.gs2.distributor.result.GetTransactionResultResult;

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

try {
    GetTransactionResultResult result = client.getTransactionResult(
        new GetTransactionResultRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
    );
    TransactionResult item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.GetTransactionResultResult> asyncResult = null;
yield return client.GetTransactionResult(
    new Gs2.Gs2Distributor.Request.GetTransactionResultRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec"),
    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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.getTransactionResult(
        new Gs2Distributor.GetTransactionResultRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.get_transaction_result(
        distributor.GetTransactionResultRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_transaction_id('cc1985c3-54f0-4fc3-b295-dc30214284ec')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.get_transaction_result({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.get_transaction_result_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetTransactionResultByUserIdRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->getTransactionResultByUserId(
        (new GetTransactionResultByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.GetTransactionResultByUserIdRequest;
import io.gs2.distributor.result.GetTransactionResultByUserIdResult;

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

try {
    GetTransactionResultByUserIdResult result = client.getTransactionResultByUserId(
        new GetTransactionResultByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
            .withTimeOffsetToken(null)
    );
    TransactionResult item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.GetTransactionResultByUserIdResult> asyncResult = null;
yield return client.GetTransactionResultByUserId(
    new Gs2.Gs2Distributor.Request.GetTransactionResultByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
        .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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.getTransactionResultByUserId(
        new Gs2Distributor.GetTransactionResultByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTransactionId("cc1985c3-54f0-4fc3-b295-dc30214284ec")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.get_transaction_result_by_user_id(
        distributor.GetTransactionResultByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_transaction_id('cc1985c3-54f0-4fc3-b295-dc30214284ec')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.get_transaction_result_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.get_transaction_result_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    transactionId="cc1985c3-54f0-4fc3-b295-dc30214284ec",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\DescribeDistributorModelsRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->describeDistributorModels(
        (new DescribeDistributorModelsRequest())
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.DescribeDistributorModelsRequest;
import io.gs2.distributor.result.DescribeDistributorModelsResult;

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

try {
    DescribeDistributorModelsResult result = client.describeDistributorModels(
        new DescribeDistributorModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<DistributorModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.DescribeDistributorModelsResult> asyncResult = null;
yield return client.DescribeDistributorModels(
    new Gs2.Gs2Distributor.Request.DescribeDistributorModelsRequest()
        .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 Gs2Distributor from '@/gs2/distributor';

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

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

from gs2 import core
from gs2 import distributor

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

try:
    result = client.describe_distributor_models(
        distributor.DescribeDistributorModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

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

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

result = api_result.result
items = result.items;

client = gs2('distributor')

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

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

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

result = api_result.result
items = result.items;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetDistributorModelRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->getDistributorModel(
        (new GetDistributorModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withDistributorName("distributor-model-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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.GetDistributorModelRequest;
import io.gs2.distributor.result.GetDistributorModelResult;

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

try {
    GetDistributorModelResult result = client.getDistributorModel(
        new GetDistributorModelRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
    );
    DistributorModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.GetDistributorModelResult> asyncResult = null;
yield return client.GetDistributorModel(
    new Gs2.Gs2Distributor.Request.GetDistributorModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithDistributorName("distributor-model-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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.getDistributorModel(
        new Gs2Distributor.GetDistributorModelRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.get_distributor_model(
        distributor.GetDistributorModelRequest()
            .with_namespace_name('namespace-0001')
            .with_distributor_name('distributor-model-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.get_distributor_model({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.get_distributor_model_async({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\ExportMasterRequest;

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

$session->open();

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

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

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

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

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

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

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

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

from gs2 import core
from gs2 import distributor

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

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

client = gs2('distributor')

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

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

result = api_result.result
item = result.item;

client = gs2('distributor')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetCurrentDistributorMasterRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->getCurrentDistributorMaster(
        (new GetCurrentDistributorMasterRequest())
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.GetCurrentDistributorMasterRequest;
import io.gs2.distributor.result.GetCurrentDistributorMasterResult;

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

try {
    GetCurrentDistributorMasterResult result = client.getCurrentDistributorMaster(
        new GetCurrentDistributorMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentDistributorMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.GetCurrentDistributorMasterResult> asyncResult = null;
yield return client.GetCurrentDistributorMaster(
    new Gs2.Gs2Distributor.Request.GetCurrentDistributorMasterRequest()
        .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 Gs2Distributor from '@/gs2/distributor';

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

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

from gs2 import core
from gs2 import distributor

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

try:
    result = client.get_current_distributor_master(
        distributor.GetCurrentDistributorMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

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

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

result = api_result.result
item = result.item;

client = gs2('distributor')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\PreUpdateCurrentDistributorMasterRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentDistributorMaster(
        (new PreUpdateCurrentDistributorMasterRequest())
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.PreUpdateCurrentDistributorMasterRequest;
import io.gs2.distributor.result.PreUpdateCurrentDistributorMasterResult;

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

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

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

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

AsyncResult<Gs2.Gs2Distributor.Result.PreUpdateCurrentDistributorMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentDistributorMaster(
    new Gs2.Gs2Distributor.Request.PreUpdateCurrentDistributorMasterRequest()
        .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 Gs2Distributor from '@/gs2/distributor';

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

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

from gs2 import core
from gs2 import distributor

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

try:
    result = client.pre_update_current_distributor_master(
        distributor.PreUpdateCurrentDistributorMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

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

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

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

client = gs2('distributor')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\UpdateCurrentDistributorMasterRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->updateCurrentDistributorMaster(
        (new UpdateCurrentDistributorMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings("{\n  \"version\": \"2019-03-01\",\n  \"distributorModels\": [\n    {\n      \"name\": \"basic\",\n      \"metadata\": \"BASIC\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\"\n    },\n    {\n      \"name\": \"special\",\n      \"metadata\": \"SPECIAL\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\",\n      \"whiteListTargetIds\": [\n        \"test\"\n      ]\n    }\n  ]\n}")
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.UpdateCurrentDistributorMasterRequest;
import io.gs2.distributor.result.UpdateCurrentDistributorMasterResult;

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

try {
    UpdateCurrentDistributorMasterResult result = client.updateCurrentDistributorMaster(
        new UpdateCurrentDistributorMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\n  \"version\": \"2019-03-01\",\n  \"distributorModels\": [\n    {\n      \"name\": \"basic\",\n      \"metadata\": \"BASIC\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\"\n    },\n    {\n      \"name\": \"special\",\n      \"metadata\": \"SPECIAL\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\",\n      \"whiteListTargetIds\": [\n        \"test\"\n      ]\n    }\n  ]\n}")
            .withUploadToken(null)
    );
    CurrentDistributorMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.UpdateCurrentDistributorMasterResult> asyncResult = null;
yield return client.UpdateCurrentDistributorMaster(
    new Gs2.Gs2Distributor.Request.UpdateCurrentDistributorMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\n  \"version\": \"2019-03-01\",\n  \"distributorModels\": [\n    {\n      \"name\": \"basic\",\n      \"metadata\": \"BASIC\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\"\n    },\n    {\n      \"name\": \"special\",\n      \"metadata\": \"SPECIAL\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\",\n      \"whiteListTargetIds\": [\n        \"test\"\n      ]\n    }\n  ]\n}")
        .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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.updateCurrentDistributorMaster(
        new Gs2Distributor.UpdateCurrentDistributorMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\n  \"version\": \"2019-03-01\",\n  \"distributorModels\": [\n    {\n      \"name\": \"basic\",\n      \"metadata\": \"BASIC\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\"\n    },\n    {\n      \"name\": \"special\",\n      \"metadata\": \"SPECIAL\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\",\n      \"whiteListTargetIds\": [\n        \"test\"\n      ]\n    }\n  ]\n}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.update_current_distributor_master(
        distributor.UpdateCurrentDistributorMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{\n  "version": "2019-03-01",\n  "distributorModels": [\n    {\n      "name": "basic",\n      "metadata": "BASIC",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001"\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001",\n      "whiteListTargetIds": [\n        "test"\n      ]\n    }\n  ]\n}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.update_current_distributor_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\n  \"version\": \"2019-03-01\",\n  \"distributorModels\": [\n    {\n      \"name\": \"basic\",\n      \"metadata\": \"BASIC\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\"\n    },\n    {\n      \"name\": \"special\",\n      \"metadata\": \"SPECIAL\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\",\n      \"whiteListTargetIds\": [\n        \"test\"\n      ]\n    }\n  ]\n}",
    uploadToken=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.update_current_distributor_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\n  \"version\": \"2019-03-01\",\n  \"distributorModels\": [\n    {\n      \"name\": \"basic\",\n      \"metadata\": \"BASIC\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\"\n    },\n    {\n      \"name\": \"special\",\n      \"metadata\": \"SPECIAL\",\n      \"inboxNamespaceId\": \"grn:gs2:ap-northeast-1:YourOwnerId:inbox:inbox-0001\",\n      \"whiteListTargetIds\": [\n        \"test\"\n      ]\n    }\n  ]\n}",
    uploadToken=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\UpdateCurrentDistributorMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->updateCurrentDistributorMasterFromGitHub(
        (new UpdateCurrentDistributorMasterFromGitHubRequest())
            ->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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.UpdateCurrentDistributorMasterFromGitHubRequest;
import io.gs2.distributor.result.UpdateCurrentDistributorMasterFromGitHubResult;

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

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

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

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

AsyncResult<Gs2.Gs2Distributor.Result.UpdateCurrentDistributorMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentDistributorMasterFromGitHub(
    new Gs2.Gs2Distributor.Request.UpdateCurrentDistributorMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2Distributor.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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.updateCurrentDistributorMasterFromGitHub(
        new Gs2Distributor.UpdateCurrentDistributorMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2Distributor.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 distributor

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

try:
    result = client.update_current_distributor_master_from_git_hub(
        distributor.UpdateCurrentDistributorMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(distributor.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('distributor')

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

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

result = api_result.result
item = result.item;

client = gs2('distributor')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\DescribeDistributorModelMastersRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

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

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.DescribeDistributorModelMastersRequest;
import io.gs2.distributor.result.DescribeDistributorModelMastersResult;

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

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

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

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

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

import Gs2Core from '@/gs2/core';
import * as Gs2Distributor from '@/gs2/distributor';

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

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

from gs2 import core
from gs2 import distributor

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

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

client = gs2('distributor')

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

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

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

client = gs2('distributor')

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

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\CreateDistributorModelMasterRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->createDistributorModelMaster(
        (new CreateDistributorModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("distributor-model-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withInboxNamespaceId(null)
            ->withWhiteListTargetIds(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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.CreateDistributorModelMasterRequest;
import io.gs2.distributor.result.CreateDistributorModelMasterResult;

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

try {
    CreateDistributorModelMasterResult result = client.createDistributorModelMaster(
        new CreateDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("distributor-model-0001")
            .withDescription(null)
            .withMetadata(null)
            .withInboxNamespaceId(null)
            .withWhiteListTargetIds(null)
    );
    DistributorModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.CreateDistributorModelMasterResult> asyncResult = null;
yield return client.CreateDistributorModelMaster(
    new Gs2.Gs2Distributor.Request.CreateDistributorModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("distributor-model-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithInboxNamespaceId(null)
        .WithWhiteListTargetIds(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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.createDistributorModelMaster(
        new Gs2Distributor.CreateDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("distributor-model-0001")
            .withDescription(null)
            .withMetadata(null)
            .withInboxNamespaceId(null)
            .withWhiteListTargetIds(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.create_distributor_model_master(
        distributor.CreateDistributorModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('distributor-model-0001')
            .with_description(None)
            .with_metadata(None)
            .with_inbox_namespace_id(None)
            .with_white_list_target_ids(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.create_distributor_model_master({
    namespaceName="namespace-0001",
    name="distributor-model-0001",
    description=nil,
    metadata=nil,
    inboxNamespaceId=nil,
    whiteListTargetIds=nil,
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.create_distributor_model_master_async({
    namespaceName="namespace-0001",
    name="distributor-model-0001",
    description=nil,
    metadata=nil,
    inboxNamespaceId=nil,
    whiteListTargetIds=nil,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\GetDistributorModelMasterRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->getDistributorModelMaster(
        (new GetDistributorModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withDistributorName("distributor-model-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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.GetDistributorModelMasterRequest;
import io.gs2.distributor.result.GetDistributorModelMasterResult;

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

try {
    GetDistributorModelMasterResult result = client.getDistributorModelMaster(
        new GetDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
    );
    DistributorModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.GetDistributorModelMasterResult> asyncResult = null;
yield return client.GetDistributorModelMaster(
    new Gs2.Gs2Distributor.Request.GetDistributorModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithDistributorName("distributor-model-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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.getDistributorModelMaster(
        new Gs2Distributor.GetDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.get_distributor_model_master(
        distributor.GetDistributorModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_distributor_name('distributor-model-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.get_distributor_model_master({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.get_distributor_model_master_async({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\UpdateDistributorModelMasterRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->updateDistributorModelMaster(
        (new UpdateDistributorModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withDistributorName("distributor-model-0001")
            ->withDescription("description1")
            ->withMetadata("{\"hoge\": \"fuga\"}")
            ->withInboxNamespaceId("inbox-0001")
            ->withWhiteListTargetIds([
                "grn:AAA",
                "grn:BBB",
            ])
    );
    $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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.UpdateDistributorModelMasterRequest;
import io.gs2.distributor.result.UpdateDistributorModelMasterResult;

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

try {
    UpdateDistributorModelMasterResult result = client.updateDistributorModelMaster(
        new UpdateDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
            .withDescription("description1")
            .withMetadata("{\"hoge\": \"fuga\"}")
            .withInboxNamespaceId("inbox-0001")
            .withWhiteListTargetIds(Arrays.asList(
                "grn:AAA",
                "grn:BBB"
            ))
    );
    DistributorModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.UpdateDistributorModelMasterResult> asyncResult = null;
yield return client.UpdateDistributorModelMaster(
    new Gs2.Gs2Distributor.Request.UpdateDistributorModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithDistributorName("distributor-model-0001")
        .WithDescription("description1")
        .WithMetadata("{\"hoge\": \"fuga\"}")
        .WithInboxNamespaceId("inbox-0001")
        .WithWhiteListTargetIds(new string[] {
            "grn:AAA",
            "grn:BBB",
        }),
    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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.updateDistributorModelMaster(
        new Gs2Distributor.UpdateDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
            .withDescription("description1")
            .withMetadata("{\"hoge\": \"fuga\"}")
            .withInboxNamespaceId("inbox-0001")
            .withWhiteListTargetIds([
                "grn:AAA",
                "grn:BBB",
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.update_distributor_model_master(
        distributor.UpdateDistributorModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_distributor_name('distributor-model-0001')
            .with_description('description1')
            .with_metadata('{"hoge": "fuga"}')
            .with_inbox_namespace_id('inbox-0001')
            .with_white_list_target_ids([
                'grn:AAA',
                'grn:BBB',
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.update_distributor_model_master({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
    description="description1",
    metadata="{\"hoge\": \"fuga\"}",
    inboxNamespaceId="inbox-0001",
    whiteListTargetIds={
        "grn:AAA",
        "grn:BBB"
    },
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.update_distributor_model_master_async({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
    description="description1",
    metadata="{\"hoge\": \"fuga\"}",
    inboxNamespaceId="inbox-0001",
    whiteListTargetIds={
        "grn:AAA",
        "grn:BBB"
    },
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Distributor\Gs2DistributorRestClient;
use Gs2\Distributor\Request\DeleteDistributorModelMasterRequest;

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

$session->open();

$client = new Gs2DistributorRestClient(
    $session
);

try {
    $result = $client->deleteDistributorModelMaster(
        (new DeleteDistributorModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withDistributorName("distributor-model-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.distributor.rest.Gs2DistributorRestClient;
import io.gs2.distributor.request.DeleteDistributorModelMasterRequest;
import io.gs2.distributor.result.DeleteDistributorModelMasterResult;

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

try {
    DeleteDistributorModelMasterResult result = client.deleteDistributorModelMaster(
        new DeleteDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
    );
    DistributorModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Distributor.Result.DeleteDistributorModelMasterResult> asyncResult = null;
yield return client.DeleteDistributorModelMaster(
    new Gs2.Gs2Distributor.Request.DeleteDistributorModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithDistributorName("distributor-model-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 Gs2Distributor from '@/gs2/distributor';

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

try {
    const result = await client.deleteDistributorModelMaster(
        new Gs2Distributor.DeleteDistributorModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withDistributorName("distributor-model-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import distributor

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

try:
    result = client.delete_distributor_model_master(
        distributor.DeleteDistributorModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_distributor_name('distributor-model-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('distributor')

api_result = client.delete_distributor_model_master({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
})

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

result = api_result.result
item = result.item;

client = gs2('distributor')

api_result_handler = client.delete_distributor_model_master_async({
    namespaceName="namespace-0001",
    distributorName="distributor-model-0001",
})

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

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

result = api_result.result
item = result.item;