GS2-Script 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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DescribeNamespacesRequest;

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

$session->open();

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

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

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

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

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

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

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

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

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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

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

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

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

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

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

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

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

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

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

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

result = api_result.result
item = result.item;

client = gs2('script')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\GetNamespaceStatusRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import script

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

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

client = gs2('script')

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

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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\GetNamespaceRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import script

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

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

client = gs2('script')

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

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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

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

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

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

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

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

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

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

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

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

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

result = api_result.result
item = result.item;

client = gs2('script')

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

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DeleteNamespaceRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import script

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

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

client = gs2('script')

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

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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\GetServiceVersionRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import script

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

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

client = gs2('script')

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

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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DescribeScriptsRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->describeScripts(
        (new DescribeScriptsRequest())
            ->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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DescribeScriptsRequest;
import io.gs2.script.result.DescribeScriptsResult;

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

try {
    DescribeScriptsResult result = client.describeScripts(
        new DescribeScriptsRequest()
            .withNamespaceName("namespace-0001")
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    List<Script> 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.DescribeScriptsResult> asyncResult = null;
yield return client.DescribeScripts(
    new Gs2.Gs2Script.Request.DescribeScriptsRequest()
        .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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.describeScripts(
        new Gs2Script.DescribeScriptsRequest()
            .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 script

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

try:
    result = client.describe_scripts(
        script.DescribeScriptsRequest()
            .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('script')

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

api_result_handler = client.describe_scripts_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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\CreateScriptRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->createScript(
        (new CreateScriptRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("script-0001")
            ->withDescription(null)
            ->withScript("result = {permit=true}")
            ->withDisableStringNumberToNumber(false)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.CreateScriptRequest;
import io.gs2.script.result.CreateScriptResult;

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

try {
    CreateScriptResult result = client.createScript(
        new CreateScriptRequest()
            .withNamespaceName("namespace-0001")
            .withName("script-0001")
            .withDescription(null)
            .withScript("result = {permit=true}")
            .withDisableStringNumberToNumber(false)
    );
    Script 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.CreateScriptResult> asyncResult = null;
yield return client.CreateScript(
    new Gs2.Gs2Script.Request.CreateScriptRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("script-0001")
        .WithDescription(null)
        .WithScript("result = {permit=true}")
        .WithDisableStringNumberToNumber(false),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Script from '@/gs2/script';

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

try {
    const result = await client.createScript(
        new Gs2Script.CreateScriptRequest()
            .withNamespaceName("namespace-0001")
            .withName("script-0001")
            .withDescription(null)
            .withScript("result = {permit=true}")
            .withDisableStringNumberToNumber(false)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.create_script(
        script.CreateScriptRequest()
            .with_namespace_name('namespace-0001')
            .with_name('script-0001')
            .with_description(None)
            .with_script('result = {permit=true}')
            .with_disable_string_number_to_number(False)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.create_script({
    namespaceName="namespace-0001",
    name="script-0001",
    description=nil,
    script="result = {permit=true}",
    disableStringNumberToNumber=false,
})

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

result = api_result.result
item = result.item;

client = gs2('script')

api_result_handler = client.create_script_async({
    namespaceName="namespace-0001",
    name="script-0001",
    description=nil,
    script="result = {permit=true}",
    disableStringNumberToNumber=false,
})

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

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

result = api_result.result
item = result.item;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\CreateScriptFromGitHubRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->createScriptFromGitHub(
        (new CreateScriptFromGitHubRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("script-0001")
            ->withDescription(null)
            ->withCheckoutSetting((new GitHubCheckoutSetting())
                ->withApiKeyId("apiKeyId-0001")
                ->withRepositoryName("gs2io/script-data")
                ->withSourcePath("path/to/file.json")
                ->withReferenceType("branch")
                ->withBranchName("develop")
            )
            ->withDisableStringNumberToNumber(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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.CreateScriptFromGitHubRequest;
import io.gs2.script.result.CreateScriptFromGitHubResult;

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

try {
    CreateScriptFromGitHubResult result = client.createScriptFromGitHub(
        new CreateScriptFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withName("script-0001")
            .withDescription(null)
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/script-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
            .withDisableStringNumberToNumber(null)
    );
    Script 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.CreateScriptFromGitHubResult> asyncResult = null;
yield return client.CreateScriptFromGitHub(
    new Gs2.Gs2Script.Request.CreateScriptFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("script-0001")
        .WithDescription(null)
        .WithCheckoutSetting(new Gs2.Gs2Script.Model.GitHubCheckoutSetting()
            .WithApiKeyId("apiKeyId-0001")
            .WithRepositoryName("gs2io/script-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        )
        .WithDisableStringNumberToNumber(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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.createScriptFromGitHub(
        new Gs2Script.CreateScriptFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withName("script-0001")
            .withDescription(null)
            .withCheckoutSetting(new Gs2Script.model.GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/script-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
            .withDisableStringNumberToNumber(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.create_script_from_git_hub(
        script.CreateScriptFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_name('script-0001')
            .with_description(None)
            .with_checkout_setting(script.GitHubCheckoutSetting()
                .with_api_key_id('apiKeyId-0001')
                .with_repository_name('gs2io/script-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
            .with_disable_string_number_to_number(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.create_script_from_git_hub({
    namespaceName="namespace-0001",
    name="script-0001",
    description=nil,
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/script-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
    disableStringNumberToNumber=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('script')

api_result_handler = client.create_script_from_git_hub_async({
    namespaceName="namespace-0001",
    name="script-0001",
    description=nil,
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/script-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
    disableStringNumberToNumber=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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\GetScriptRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->getScript(
        (new GetScriptRequest())
            ->withNamespaceName("namespace-0001")
            ->withScriptName("script-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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.GetScriptRequest;
import io.gs2.script.result.GetScriptResult;

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

try {
    GetScriptResult result = client.getScript(
        new GetScriptRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
    );
    Script 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.GetScriptResult> asyncResult = null;
yield return client.GetScript(
    new Gs2.Gs2Script.Request.GetScriptRequest()
        .WithNamespaceName("namespace-0001")
        .WithScriptName("script-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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.getScript(
        new Gs2Script.GetScriptRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.get_script(
        script.GetScriptRequest()
            .with_namespace_name('namespace-0001')
            .with_script_name('script-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.get_script({
    namespaceName="namespace-0001",
    scriptName="script-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('script')

api_result_handler = client.get_script_async({
    namespaceName="namespace-0001",
    scriptName="script-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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\UpdateScriptRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->updateScript(
        (new UpdateScriptRequest())
            ->withNamespaceName("namespace-0001")
            ->withScriptName("script-0001")
            ->withDescription("description1")
            ->withScript("result = \"hogehoge\"")
            ->withDisableStringNumberToNumber(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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.UpdateScriptRequest;
import io.gs2.script.result.UpdateScriptResult;

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

try {
    UpdateScriptResult result = client.updateScript(
        new UpdateScriptRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
            .withDescription("description1")
            .withScript("result = \"hogehoge\"")
            .withDisableStringNumberToNumber(null)
    );
    Script 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.UpdateScriptResult> asyncResult = null;
yield return client.UpdateScript(
    new Gs2.Gs2Script.Request.UpdateScriptRequest()
        .WithNamespaceName("namespace-0001")
        .WithScriptName("script-0001")
        .WithDescription("description1")
        .WithScript("result = \"hogehoge\"")
        .WithDisableStringNumberToNumber(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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.updateScript(
        new Gs2Script.UpdateScriptRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
            .withDescription("description1")
            .withScript("result = \"hogehoge\"")
            .withDisableStringNumberToNumber(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.update_script(
        script.UpdateScriptRequest()
            .with_namespace_name('namespace-0001')
            .with_script_name('script-0001')
            .with_description('description1')
            .with_script('result = "hogehoge"')
            .with_disable_string_number_to_number(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.update_script({
    namespaceName="namespace-0001",
    scriptName="script-0001",
    description="description1",
    script="result = \"hogehoge\"",
    disableStringNumberToNumber=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('script')

api_result_handler = client.update_script_async({
    namespaceName="namespace-0001",
    scriptName="script-0001",
    description="description1",
    script="result = \"hogehoge\"",
    disableStringNumberToNumber=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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\UpdateScriptFromGitHubRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->updateScriptFromGitHub(
        (new UpdateScriptFromGitHubRequest())
            ->withNamespaceName("namespace-0001")
            ->withScriptName("script-0001")
            ->withDescription(null)
            ->withCheckoutSetting((new GitHubCheckoutSetting())
                ->withApiKeyId("apiKeyId-0001")
                ->withRepositoryName("gs2io/script-data")
                ->withSourcePath("path/to/file.json")
                ->withReferenceType("branch")
                ->withBranchName("develop")
            )
            ->withDisableStringNumberToNumber(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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.UpdateScriptFromGitHubRequest;
import io.gs2.script.result.UpdateScriptFromGitHubResult;

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

try {
    UpdateScriptFromGitHubResult result = client.updateScriptFromGitHub(
        new UpdateScriptFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
            .withDescription(null)
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/script-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
            .withDisableStringNumberToNumber(null)
    );
    Script 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.UpdateScriptFromGitHubResult> asyncResult = null;
yield return client.UpdateScriptFromGitHub(
    new Gs2.Gs2Script.Request.UpdateScriptFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithScriptName("script-0001")
        .WithDescription(null)
        .WithCheckoutSetting(new Gs2.Gs2Script.Model.GitHubCheckoutSetting()
            .WithApiKeyId("apiKeyId-0001")
            .WithRepositoryName("gs2io/script-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        )
        .WithDisableStringNumberToNumber(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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.updateScriptFromGitHub(
        new Gs2Script.UpdateScriptFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
            .withDescription(null)
            .withCheckoutSetting(new Gs2Script.model.GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/script-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
            .withDisableStringNumberToNumber(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.update_script_from_git_hub(
        script.UpdateScriptFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_script_name('script-0001')
            .with_description(None)
            .with_checkout_setting(script.GitHubCheckoutSetting()
                .with_api_key_id('apiKeyId-0001')
                .with_repository_name('gs2io/script-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
            .with_disable_string_number_to_number(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.update_script_from_git_hub({
    namespaceName="namespace-0001",
    scriptName="script-0001",
    description=nil,
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/script-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
    disableStringNumberToNumber=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('script')

api_result_handler = client.update_script_from_git_hub_async({
    namespaceName="namespace-0001",
    scriptName="script-0001",
    description=nil,
    checkoutSetting={
        api_key_id="apiKeyId-0001",
        repository_name="gs2io/script-data",
        source_path="path/to/file.json",
        reference_type="branch",
        branch_name="develop",
    },
    disableStringNumberToNumber=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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DeleteScriptRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->deleteScript(
        (new DeleteScriptRequest())
            ->withNamespaceName("namespace-0001")
            ->withScriptName("script-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.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DeleteScriptRequest;
import io.gs2.script.result.DeleteScriptResult;

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

try {
    DeleteScriptResult result = client.deleteScript(
        new DeleteScriptRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
    );
    Script 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.DeleteScriptResult> asyncResult = null;
yield return client.DeleteScript(
    new Gs2.Gs2Script.Request.DeleteScriptRequest()
        .WithNamespaceName("namespace-0001")
        .WithScriptName("script-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 Gs2Script from '@/gs2/script';

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

try {
    const result = await client.deleteScript(
        new Gs2Script.DeleteScriptRequest()
            .withNamespaceName("namespace-0001")
            .withScriptName("script-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.delete_script(
        script.DeleteScriptRequest()
            .with_namespace_name('namespace-0001')
            .with_script_name('script-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.delete_script({
    namespaceName="namespace-0001",
    scriptName="script-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('script')

api_result_handler = client.delete_script_async({
    namespaceName="namespace-0001",
    scriptName="script-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\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\InvokeScriptRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->invokeScript(
        (new InvokeScriptRequest())
            ->withScriptId("script-0001")
            ->withUserId(null)
            ->withArgs("{}")
            ->withRandomStatus(null)
            ->withTimeOffsetToken(null)
    );
    $code = $result->getCode();
    $result = $result->getResult();
    $transaction = $result->getTransaction();
    $randomStatus = $result->getRandomStatus();
    $atomicCommit = $result->getAtomicCommit();
    $transactionResult = $result->getTransactionResult();
    $executeTime = $result->getExecuteTime();
    $charged = $result->getCharged();
    $output = $result->getOutput();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.InvokeScriptRequest;
import io.gs2.script.result.InvokeScriptResult;

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

try {
    InvokeScriptResult result = client.invokeScript(
        new InvokeScriptRequest()
            .withScriptId("script-0001")
            .withUserId(null)
            .withArgs("{}")
            .withRandomStatus(null)
            .withTimeOffsetToken(null)
    );
    int code = result.getCode();
    String result = result.getResult();
    Transaction transaction = result.getTransaction();
    RandomStatus randomStatus = result.getRandomStatus();
    boolean atomicCommit = result.getAtomicCommit();
    TransactionResult transactionResult = result.getTransactionResult();
    int executeTime = result.getExecuteTime();
    int charged = result.getCharged();
    List<String> output = result.getOutput();
} 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.InvokeScriptResult> asyncResult = null;
yield return client.InvokeScript(
    new Gs2.Gs2Script.Request.InvokeScriptRequest()
        .WithScriptId("script-0001")
        .WithUserId(null)
        .WithArgs("{}")
        .WithRandomStatus(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var code = result.Code;
var result = result.Result;
var transaction = result.Transaction;
var randomStatus = result.RandomStatus;
var atomicCommit = result.AtomicCommit;
var transactionResult = result.TransactionResult;
var executeTime = result.ExecuteTime;
var charged = result.Charged;
var output = result.Output;

import Gs2Core from '@/gs2/core';
import * as Gs2Script from '@/gs2/script';

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

try {
    const result = await client.invokeScript(
        new Gs2Script.InvokeScriptRequest()
            .withScriptId("script-0001")
            .withUserId(null)
            .withArgs("{}")
            .withRandomStatus(null)
            .withTimeOffsetToken(null)
    );
    const code = result.getCode();
    const result = result.getResult();
    const transaction = result.getTransaction();
    const randomStatus = result.getRandomStatus();
    const atomicCommit = result.getAtomicCommit();
    const transactionResult = result.getTransactionResult();
    const executeTime = result.getExecuteTime();
    const charged = result.getCharged();
    const output = result.getOutput();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.invoke_script(
        script.InvokeScriptRequest()
            .with_script_id('script-0001')
            .with_user_id(None)
            .with_args('{}')
            .with_random_status(None)
            .with_time_offset_token(None)
    )
    code = result.code
    result = result.result
    transaction = result.transaction
    random_status = result.random_status
    atomic_commit = result.atomic_commit
    transaction_result = result.transaction_result
    execute_time = result.execute_time
    charged = result.charged
    output = result.output
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.invoke_script({
    scriptId="script-0001",
    userId=nil,
    args="{}",
    randomStatus=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
code = result.code;
result = result.result;
transaction = result.transaction;
randomStatus = result.randomStatus;
atomicCommit = result.atomicCommit;
transactionResult = result.transactionResult;
executeTime = result.executeTime;
charged = result.charged;
output = result.output;

client = gs2('script')

api_result_handler = client.invoke_script_async({
    scriptId="script-0001",
    userId=nil,
    args="{}",
    randomStatus=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
code = result.code;
result = result.result;
transaction = result.transaction;
randomStatus = result.randomStatus;
atomicCommit = result.atomicCommit;
transactionResult = result.transactionResult;
executeTime = result.executeTime;
charged = result.charged;
output = result.output;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Script\Gs2ScriptRestClient;
use Gs2\Script\Request\DebugInvokeRequest;

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

$session->open();

$client = new Gs2ScriptRestClient(
    $session
);

try {
    $result = $client->debugInvoke(
        (new DebugInvokeRequest())
            ->withScript("result = \"hello\"")
            ->withArgs("{}")
            ->withUserId(null)
            ->withRandomStatus(null)
            ->withDisableStringNumberToNumber(null)
            ->withTimeOffsetToken(null)
    );
    $code = $result->getCode();
    $result = $result->getResult();
    $transaction = $result->getTransaction();
    $randomStatus = $result->getRandomStatus();
    $atomicCommit = $result->getAtomicCommit();
    $transactionResult = $result->getTransactionResult();
    $executeTime = $result->getExecuteTime();
    $charged = $result->getCharged();
    $output = $result->getOutput();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.script.rest.Gs2ScriptRestClient;
import io.gs2.script.request.DebugInvokeRequest;
import io.gs2.script.result.DebugInvokeResult;

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

try {
    DebugInvokeResult result = client.debugInvoke(
        new DebugInvokeRequest()
            .withScript("result = \"hello\"")
            .withArgs("{}")
            .withUserId(null)
            .withRandomStatus(null)
            .withDisableStringNumberToNumber(null)
            .withTimeOffsetToken(null)
    );
    int code = result.getCode();
    String result = result.getResult();
    Transaction transaction = result.getTransaction();
    RandomStatus randomStatus = result.getRandomStatus();
    boolean atomicCommit = result.getAtomicCommit();
    TransactionResult transactionResult = result.getTransactionResult();
    int executeTime = result.getExecuteTime();
    int charged = result.getCharged();
    List<String> output = result.getOutput();
} 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 Gs2ScriptRestClient(session);

AsyncResult<Gs2.Gs2Script.Result.DebugInvokeResult> asyncResult = null;
yield return client.DebugInvoke(
    new Gs2.Gs2Script.Request.DebugInvokeRequest()
        .WithScript("result = \"hello\"")
        .WithArgs("{}")
        .WithUserId(null)
        .WithRandomStatus(null)
        .WithDisableStringNumberToNumber(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var code = result.Code;
var result = result.Result;
var transaction = result.Transaction;
var randomStatus = result.RandomStatus;
var atomicCommit = result.AtomicCommit;
var transactionResult = result.TransactionResult;
var executeTime = result.ExecuteTime;
var charged = result.Charged;
var output = result.Output;

import Gs2Core from '@/gs2/core';
import * as Gs2Script from '@/gs2/script';

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

try {
    const result = await client.debugInvoke(
        new Gs2Script.DebugInvokeRequest()
            .withScript("result = \"hello\"")
            .withArgs("{}")
            .withUserId(null)
            .withRandomStatus(null)
            .withDisableStringNumberToNumber(null)
            .withTimeOffsetToken(null)
    );
    const code = result.getCode();
    const result = result.getResult();
    const transaction = result.getTransaction();
    const randomStatus = result.getRandomStatus();
    const atomicCommit = result.getAtomicCommit();
    const transactionResult = result.getTransactionResult();
    const executeTime = result.getExecuteTime();
    const charged = result.getCharged();
    const output = result.getOutput();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import script

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

try:
    result = client.debug_invoke(
        script.DebugInvokeRequest()
            .with_script('result = "hello"')
            .with_args('{}')
            .with_user_id(None)
            .with_random_status(None)
            .with_disable_string_number_to_number(None)
            .with_time_offset_token(None)
    )
    code = result.code
    result = result.result
    transaction = result.transaction
    random_status = result.random_status
    atomic_commit = result.atomic_commit
    transaction_result = result.transaction_result
    execute_time = result.execute_time
    charged = result.charged
    output = result.output
except core.Gs2Exception as e:
    exit(1)

client = gs2('script')

api_result = client.debug_invoke({
    script="result = \"hello\"",
    args="{}",
    userId=nil,
    randomStatus=nil,
    disableStringNumberToNumber=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
code = result.code;
result = result.result;
transaction = result.transaction;
randomStatus = result.randomStatus;
atomicCommit = result.atomicCommit;
transactionResult = result.transactionResult;
executeTime = result.executeTime;
charged = result.charged;
output = result.output;

client = gs2('script')

api_result_handler = client.debug_invoke_async({
    script="result = \"hello\"",
    args="{}",
    userId=nil,
    randomStatus=nil,
    disableStringNumberToNumber=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
code = result.code;
result = result.result;
transaction = result.transaction;
randomStatus = result.randomStatus;
atomicCommit = result.atomicCommit;
transactionResult = result.transactionResult;
executeTime = result.executeTime;
charged = result.charged;
output = result.output;