GS2-Identifier SDK API リファレンス

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeIdentifiersRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->describeIdentifiers(
        (new DescribeIdentifiersRequest())
            ->withUserName("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeIdentifiersRequest;
import io.gs2.identifier.result.DescribeIdentifiersResult;

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

try {
    DescribeIdentifiersResult result = client.describeIdentifiers(
        new DescribeIdentifiersRequest()
            .withUserName("user-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Identifier> 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DescribeIdentifiersResult> asyncResult = null;
yield return client.DescribeIdentifiers(
    new Gs2.Gs2Identifier.Request.DescribeIdentifiersRequest()
        .WithUserName("user-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.describeIdentifiers(
        new Gs2Identifier.DescribeIdentifiersRequest()
            .withUserName("user-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.describe_identifiers(
        identifier.DescribeIdentifiersRequest()
            .with_user_name('user-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.describe_identifiers({
    userName="user-0001",
    pageToken=nil,
    limit=nil,
})

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

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

client = gs2('identifier')

api_result_handler = client.describe_identifiers_async({
    userName="user-0001",
    pageToken=nil,
    limit=nil,
})

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

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

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

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\CreateIdentifierRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->createIdentifier(
        (new CreateIdentifierRequest())
            ->withUserName("user-0001")
    );
    $item = $result->getItem();
    $clientSecret = $result->getClientSecret();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreateIdentifierRequest;
import io.gs2.identifier.result.CreateIdentifierResult;

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

try {
    CreateIdentifierResult result = client.createIdentifier(
        new CreateIdentifierRequest()
            .withUserName("user-0001")
    );
    Identifier item = result.getItem();
    String clientSecret = result.getClientSecret();
} 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.CreateIdentifierResult> asyncResult = null;
yield return client.CreateIdentifier(
    new Gs2.Gs2Identifier.Request.CreateIdentifierRequest()
        .WithUserName("user-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var clientSecret = result.ClientSecret;

import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.createIdentifier(
        new Gs2Identifier.CreateIdentifierRequest()
            .withUserName("user-0001")
    );
    const item = result.getItem();
    const clientSecret = result.getClientSecret();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.create_identifier(
        identifier.CreateIdentifierRequest()
            .with_user_name('user-0001')
    )
    item = result.item
    client_secret = result.client_secret
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.create_identifier({
    userName="user-0001",
})

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

result = api_result.result
item = result.item;
clientSecret = result.clientSecret;

client = gs2('identifier')

api_result_handler = client.create_identifier_async({
    userName="user-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;
clientSecret = result.clientSecret;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetIdentifierRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->getIdentifier(
        (new GetIdentifierRequest())
            ->withUserName("user-0001")
            ->withClientId("client-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetIdentifierRequest;
import io.gs2.identifier.result.GetIdentifierResult;

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

try {
    GetIdentifierResult result = client.getIdentifier(
        new GetIdentifierRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
    );
    Identifier 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.GetIdentifierResult> asyncResult = null;
yield return client.GetIdentifier(
    new Gs2.Gs2Identifier.Request.GetIdentifierRequest()
        .WithUserName("user-0001")
        .WithClientId("client-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.getIdentifier(
        new Gs2Identifier.GetIdentifierRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.get_identifier(
        identifier.GetIdentifierRequest()
            .with_user_name('user-0001')
            .with_client_id('client-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.get_identifier({
    userName="user-0001",
    clientId="client-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('identifier')

api_result_handler = client.get_identifier_async({
    userName="user-0001",
    clientId="client-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeleteIdentifierRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->deleteIdentifier(
        (new DeleteIdentifierRequest())
            ->withUserName("user-0001")
            ->withClientId("client-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeleteIdentifierRequest;
import io.gs2.identifier.result.DeleteIdentifierResult;

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

try {
    DeleteIdentifierResult result = client.deleteIdentifier(
        new DeleteIdentifierRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
    );
    Identifier 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DeleteIdentifierResult> asyncResult = null;
yield return client.DeleteIdentifier(
    new Gs2.Gs2Identifier.Request.DeleteIdentifierRequest()
        .WithUserName("user-0001")
        .WithClientId("client-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.deleteIdentifier(
        new Gs2Identifier.DeleteIdentifierRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.delete_identifier(
        identifier.DeleteIdentifierRequest()
            .with_user_name('user-0001')
            .with_client_id('client-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.delete_identifier({
    userName="user-0001",
    clientId="client-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('identifier')

api_result_handler = client.delete_identifier_async({
    userName="user-0001",
    clientId="client-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeAttachedGuardsRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->describeAttachedGuards(
        (new DescribeAttachedGuardsRequest())
            ->withClientId("client-0001")
            ->withUserName("user-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeAttachedGuardsRequest;
import io.gs2.identifier.result.DescribeAttachedGuardsResult;

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

try {
    DescribeAttachedGuardsResult result = client.describeAttachedGuards(
        new DescribeAttachedGuardsRequest()
            .withClientId("client-0001")
            .withUserName("user-0001")
    );
    List<String> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Identifier.Result.DescribeAttachedGuardsResult> asyncResult = null;
yield return client.DescribeAttachedGuards(
    new Gs2.Gs2Identifier.Request.DescribeAttachedGuardsRequest()
        .WithClientId("client-0001")
        .WithUserName("user-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.describeAttachedGuards(
        new Gs2Identifier.DescribeAttachedGuardsRequest()
            .withClientId("client-0001")
            .withUserName("user-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.describe_attached_guards(
        identifier.DescribeAttachedGuardsRequest()
            .with_client_id('client-0001')
            .with_user_name('user-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.describe_attached_guards({
    clientId="client-0001",
    userName="user-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('identifier')

api_result_handler = client.describe_attached_guards_async({
    clientId="client-0001",
    userName="user-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\AttachGuardRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->attachGuard(
        (new AttachGuardRequest())
            ->withUserName("user-0001")
            ->withClientId("client-0001")
            ->withGuardNamespaceId("guard-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.AttachGuardRequest;
import io.gs2.identifier.result.AttachGuardResult;

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

try {
    AttachGuardResult result = client.attachGuard(
        new AttachGuardRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
            .withGuardNamespaceId("guard-namespace-0001")
    );
    List<String> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Identifier.Result.AttachGuardResult> asyncResult = null;
yield return client.AttachGuard(
    new Gs2.Gs2Identifier.Request.AttachGuardRequest()
        .WithUserName("user-0001")
        .WithClientId("client-0001")
        .WithGuardNamespaceId("guard-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.attachGuard(
        new Gs2Identifier.AttachGuardRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
            .withGuardNamespaceId("guard-namespace-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.attach_guard(
        identifier.AttachGuardRequest()
            .with_user_name('user-0001')
            .with_client_id('client-0001')
            .with_guard_namespace_id('guard-namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.attach_guard({
    userName="user-0001",
    clientId="client-0001",
    guardNamespaceId="guard-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('identifier')

api_result_handler = client.attach_guard_async({
    userName="user-0001",
    clientId="client-0001",
    guardNamespaceId="guard-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DetachGuardRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->detachGuard(
        (new DetachGuardRequest())
            ->withUserName("user-0001")
            ->withClientId("client-0001")
            ->withGuardNamespaceId("guard-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DetachGuardRequest;
import io.gs2.identifier.result.DetachGuardResult;

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

try {
    DetachGuardResult result = client.detachGuard(
        new DetachGuardRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
            .withGuardNamespaceId("guard-namespace-0001")
    );
    List<String> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

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

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

AsyncResult<Gs2.Gs2Identifier.Result.DetachGuardResult> asyncResult = null;
yield return client.DetachGuard(
    new Gs2.Gs2Identifier.Request.DetachGuardRequest()
        .WithUserName("user-0001")
        .WithClientId("client-0001")
        .WithGuardNamespaceId("guard-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.detachGuard(
        new Gs2Identifier.DetachGuardRequest()
            .withUserName("user-0001")
            .withClientId("client-0001")
            .withGuardNamespaceId("guard-namespace-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.detach_guard(
        identifier.DetachGuardRequest()
            .with_user_name('user-0001')
            .with_client_id('client-0001')
            .with_guard_namespace_id('guard-namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.detach_guard({
    userName="user-0001",
    clientId="client-0001",
    guardNamespaceId="guard-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('identifier')

api_result_handler = client.detach_guard_async({
    userName="user-0001",
    clientId="client-0001",
    guardNamespaceId="guard-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetServiceVersionRequest;

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

$session->open();

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

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

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

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

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

from gs2 import core
from gs2 import identifier

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

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

client = gs2('identifier')

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

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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\CreatePasswordRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->createPassword(
        (new CreatePasswordRequest())
            ->withUserName("user-0001")
            ->withPassword("password-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreatePasswordRequest;
import io.gs2.identifier.result.CreatePasswordResult;

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

try {
    CreatePasswordResult result = client.createPassword(
        new CreatePasswordRequest()
            .withUserName("user-0001")
            .withPassword("password-0001")
    );
    Password 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.CreatePasswordResult> asyncResult = null;
yield return client.CreatePassword(
    new Gs2.Gs2Identifier.Request.CreatePasswordRequest()
        .WithUserName("user-0001")
        .WithPassword("password-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.createPassword(
        new Gs2Identifier.CreatePasswordRequest()
            .withUserName("user-0001")
            .withPassword("password-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.create_password(
        identifier.CreatePasswordRequest()
            .with_user_name('user-0001')
            .with_password('password-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.create_password({
    userName="user-0001",
    password="password-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('identifier')

api_result_handler = client.create_password_async({
    userName="user-0001",
    password="password-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetPasswordRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->getPassword(
        (new GetPasswordRequest())
            ->withUserName("user-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetPasswordRequest;
import io.gs2.identifier.result.GetPasswordResult;

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

try {
    GetPasswordResult result = client.getPassword(
        new GetPasswordRequest()
            .withUserName("user-0001")
    );
    Password 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.GetPasswordResult> asyncResult = null;
yield return client.GetPassword(
    new Gs2.Gs2Identifier.Request.GetPasswordRequest()
        .WithUserName("user-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.getPassword(
        new Gs2Identifier.GetPasswordRequest()
            .withUserName("user-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.get_password(
        identifier.GetPasswordRequest()
            .with_user_name('user-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.get_password({
    userName="user-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('identifier')

api_result_handler = client.get_password_async({
    userName="user-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\EnableMfaRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->enableMfa(
        (new EnableMfaRequest())
            ->withUserName("user-0001")
    );
    $item = $result->getItem();
    $challengeToken = $result->getChallengeToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.EnableMfaRequest;
import io.gs2.identifier.result.EnableMfaResult;

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

try {
    EnableMfaResult result = client.enableMfa(
        new EnableMfaRequest()
            .withUserName("user-0001")
    );
    Password item = result.getItem();
    String challengeToken = result.getChallengeToken();
} 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.EnableMfaResult> asyncResult = null;
yield return client.EnableMfa(
    new Gs2.Gs2Identifier.Request.EnableMfaRequest()
        .WithUserName("user-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var challengeToken = result.ChallengeToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.enableMfa(
        new Gs2Identifier.EnableMfaRequest()
            .withUserName("user-0001")
    );
    const item = result.getItem();
    const challengeToken = result.getChallengeToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.enable_mfa(
        identifier.EnableMfaRequest()
            .with_user_name('user-0001')
    )
    item = result.item
    challenge_token = result.challenge_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.enable_mfa({
    userName="user-0001",
})

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

result = api_result.result
item = result.item;
challengeToken = result.challengeToken;

client = gs2('identifier')

api_result_handler = client.enable_mfa_async({
    userName="user-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;
challengeToken = result.challengeToken;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\ChallengeMfaRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->challengeMfa(
        (new ChallengeMfaRequest())
            ->withUserName("user-0001")
            ->withPasscode("012345")
    );
    $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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.ChallengeMfaRequest;
import io.gs2.identifier.result.ChallengeMfaResult;

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

try {
    ChallengeMfaResult result = client.challengeMfa(
        new ChallengeMfaRequest()
            .withUserName("user-0001")
            .withPasscode("012345")
    );
    Password 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.ChallengeMfaResult> asyncResult = null;
yield return client.ChallengeMfa(
    new Gs2.Gs2Identifier.Request.ChallengeMfaRequest()
        .WithUserName("user-0001")
        .WithPasscode("012345"),
    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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.challengeMfa(
        new Gs2Identifier.ChallengeMfaRequest()
            .withUserName("user-0001")
            .withPasscode("012345")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.challenge_mfa(
        identifier.ChallengeMfaRequest()
            .with_user_name('user-0001')
            .with_passcode('012345')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.challenge_mfa({
    userName="user-0001",
    passcode="012345",
})

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

api_result_handler = client.challenge_mfa_async({
    userName="user-0001",
    passcode="012345",
})

api_result = 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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DisableMfaRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->disableMfa(
        (new DisableMfaRequest())
            ->withUserName("user-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DisableMfaRequest;
import io.gs2.identifier.result.DisableMfaResult;

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

try {
    DisableMfaResult result = client.disableMfa(
        new DisableMfaRequest()
            .withUserName("user-0001")
    );
    Password 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DisableMfaResult> asyncResult = null;
yield return client.DisableMfa(
    new Gs2.Gs2Identifier.Request.DisableMfaRequest()
        .WithUserName("user-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.disableMfa(
        new Gs2Identifier.DisableMfaRequest()
            .withUserName("user-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.disable_mfa(
        identifier.DisableMfaRequest()
            .with_user_name('user-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.disable_mfa({
    userName="user-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('identifier')

api_result_handler = client.disable_mfa_async({
    userName="user-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeletePasswordRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->deletePassword(
        (new DeletePasswordRequest())
            ->withUserName("user-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeletePasswordRequest;
import io.gs2.identifier.result.DeletePasswordResult;

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

try {
    DeletePasswordResult result = client.deletePassword(
        new DeletePasswordRequest()
            .withUserName("user-0001")
    );
    Password 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DeletePasswordResult> asyncResult = null;
yield return client.DeletePassword(
    new Gs2.Gs2Identifier.Request.DeletePasswordRequest()
        .WithUserName("user-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.deletePassword(
        new Gs2Identifier.DeletePasswordRequest()
            .withUserName("user-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.delete_password(
        identifier.DeletePasswordRequest()
            .with_user_name('user-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.delete_password({
    userName="user-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('identifier')

api_result_handler = client.delete_password_async({
    userName="user-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetHasSecurityPolicyRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->getHasSecurityPolicy(
        (new GetHasSecurityPolicyRequest())
            ->withUserName("user-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetHasSecurityPolicyRequest;
import io.gs2.identifier.result.GetHasSecurityPolicyResult;

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

try {
    GetHasSecurityPolicyResult result = client.getHasSecurityPolicy(
        new GetHasSecurityPolicyRequest()
            .withUserName("user-0001")
    );
    List<SecurityPolicy> 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.GetHasSecurityPolicyResult> asyncResult = null;
yield return client.GetHasSecurityPolicy(
    new Gs2.Gs2Identifier.Request.GetHasSecurityPolicyRequest()
        .WithUserName("user-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.getHasSecurityPolicy(
        new Gs2Identifier.GetHasSecurityPolicyRequest()
            .withUserName("user-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.get_has_security_policy(
        identifier.GetHasSecurityPolicyRequest()
            .with_user_name('user-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.get_has_security_policy({
    userName="user-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('identifier')

api_result_handler = client.get_has_security_policy_async({
    userName="user-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\AttachSecurityPolicyRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->attachSecurityPolicy(
        (new AttachSecurityPolicyRequest())
            ->withUserName("user-0001")
            ->withSecurityPolicyId("securityPolicyId-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.AttachSecurityPolicyRequest;
import io.gs2.identifier.result.AttachSecurityPolicyResult;

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

try {
    AttachSecurityPolicyResult result = client.attachSecurityPolicy(
        new AttachSecurityPolicyRequest()
            .withUserName("user-0001")
            .withSecurityPolicyId("securityPolicyId-0001")
    );
    List<SecurityPolicy> 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.AttachSecurityPolicyResult> asyncResult = null;
yield return client.AttachSecurityPolicy(
    new Gs2.Gs2Identifier.Request.AttachSecurityPolicyRequest()
        .WithUserName("user-0001")
        .WithSecurityPolicyId("securityPolicyId-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.attachSecurityPolicy(
        new Gs2Identifier.AttachSecurityPolicyRequest()
            .withUserName("user-0001")
            .withSecurityPolicyId("securityPolicyId-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.attach_security_policy(
        identifier.AttachSecurityPolicyRequest()
            .with_user_name('user-0001')
            .with_security_policy_id('securityPolicyId-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.attach_security_policy({
    userName="user-0001",
    securityPolicyId="securityPolicyId-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('identifier')

api_result_handler = client.attach_security_policy_async({
    userName="user-0001",
    securityPolicyId="securityPolicyId-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DetachSecurityPolicyRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->detachSecurityPolicy(
        (new DetachSecurityPolicyRequest())
            ->withUserName("user-0001")
            ->withSecurityPolicyId("securityPolicyId-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DetachSecurityPolicyRequest;
import io.gs2.identifier.result.DetachSecurityPolicyResult;

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

try {
    DetachSecurityPolicyResult result = client.detachSecurityPolicy(
        new DetachSecurityPolicyRequest()
            .withUserName("user-0001")
            .withSecurityPolicyId("securityPolicyId-0001")
    );
    List<SecurityPolicy> 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DetachSecurityPolicyResult> asyncResult = null;
yield return client.DetachSecurityPolicy(
    new Gs2.Gs2Identifier.Request.DetachSecurityPolicyRequest()
        .WithUserName("user-0001")
        .WithSecurityPolicyId("securityPolicyId-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.detachSecurityPolicy(
        new Gs2Identifier.DetachSecurityPolicyRequest()
            .withUserName("user-0001")
            .withSecurityPolicyId("securityPolicyId-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.detach_security_policy(
        identifier.DetachSecurityPolicyRequest()
            .with_user_name('user-0001')
            .with_security_policy_id('securityPolicyId-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.detach_security_policy({
    userName="user-0001",
    securityPolicyId="securityPolicyId-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('identifier')

api_result_handler = client.detach_security_policy_async({
    userName="user-0001",
    securityPolicyId="securityPolicyId-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeUsersRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->describeUsers(
        (new DescribeUsersRequest())
            ->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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeUsersRequest;
import io.gs2.identifier.result.DescribeUsersResult;

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

try {
    DescribeUsersResult result = client.describeUsers(
        new DescribeUsersRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<User> 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DescribeUsersResult> asyncResult = null;
yield return client.DescribeUsers(
    new Gs2.Gs2Identifier.Request.DescribeUsersRequest()
        .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 Gs2Identifier from '@/gs2/identifier';

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

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

from gs2 import core
from gs2 import identifier

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

try:
    result = client.describe_users(
        identifier.DescribeUsersRequest()
            .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('identifier')

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

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

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

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

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->createUser(
        (new CreateUserRequest())
            ->withName("user-0001")
            ->withDescription(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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreateUserRequest;
import io.gs2.identifier.result.CreateUserResult;

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

try {
    CreateUserResult result = client.createUser(
        new CreateUserRequest()
            .withName("user-0001")
            .withDescription(null)
    );
    User 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.CreateUserResult> asyncResult = null;
yield return client.CreateUser(
    new Gs2.Gs2Identifier.Request.CreateUserRequest()
        .WithName("user-0001")
        .WithDescription(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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.createUser(
        new Gs2Identifier.CreateUserRequest()
            .withName("user-0001")
            .withDescription(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.create_user(
        identifier.CreateUserRequest()
            .with_name('user-0001')
            .with_description(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.create_user({
    name="user-0001",
    description=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('identifier')

api_result_handler = client.create_user_async({
    name="user-0001",
    description=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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\UpdateUserRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->updateUser(
        (new UpdateUserRequest())
            ->withUserName("user-0001")
            ->withDescription("description1")
    );
    $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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.UpdateUserRequest;
import io.gs2.identifier.result.UpdateUserResult;

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

try {
    UpdateUserResult result = client.updateUser(
        new UpdateUserRequest()
            .withUserName("user-0001")
            .withDescription("description1")
    );
    User 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.UpdateUserResult> asyncResult = null;
yield return client.UpdateUser(
    new Gs2.Gs2Identifier.Request.UpdateUserRequest()
        .WithUserName("user-0001")
        .WithDescription("description1"),
    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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.updateUser(
        new Gs2Identifier.UpdateUserRequest()
            .withUserName("user-0001")
            .withDescription("description1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.update_user(
        identifier.UpdateUserRequest()
            .with_user_name('user-0001')
            .with_description('description1')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.update_user({
    userName="user-0001",
    description="description1",
})

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

api_result_handler = client.update_user_async({
    userName="user-0001",
    description="description1",
})

api_result = 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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetUserRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->getUser(
        (new GetUserRequest())
            ->withUserName("user-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetUserRequest;
import io.gs2.identifier.result.GetUserResult;

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

try {
    GetUserResult result = client.getUser(
        new GetUserRequest()
            .withUserName("user-0001")
    );
    User 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.GetUserResult> asyncResult = null;
yield return client.GetUser(
    new Gs2.Gs2Identifier.Request.GetUserRequest()
        .WithUserName("user-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.getUser(
        new Gs2Identifier.GetUserRequest()
            .withUserName("user-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.get_user(
        identifier.GetUserRequest()
            .with_user_name('user-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.get_user({
    userName="user-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('identifier')

api_result_handler = client.get_user_async({
    userName="user-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeleteUserRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->deleteUser(
        (new DeleteUserRequest())
            ->withUserName("user-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeleteUserRequest;
import io.gs2.identifier.result.DeleteUserResult;

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

try {
    DeleteUserResult result = client.deleteUser(
        new DeleteUserRequest()
            .withUserName("user-0001")
    );
    User 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DeleteUserResult> asyncResult = null;
yield return client.DeleteUser(
    new Gs2.Gs2Identifier.Request.DeleteUserRequest()
        .WithUserName("user-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.deleteUser(
        new Gs2Identifier.DeleteUserRequest()
            .withUserName("user-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.delete_user(
        identifier.DeleteUserRequest()
            .with_user_name('user-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.delete_user({
    userName="user-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('identifier')

api_result_handler = client.delete_user_async({
    userName="user-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DescribeSecurityPoliciesRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->describeSecurityPolicies(
        (new DescribeSecurityPoliciesRequest())
            ->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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeSecurityPoliciesRequest;
import io.gs2.identifier.result.DescribeSecurityPoliciesResult;

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

try {
    DescribeSecurityPoliciesResult result = client.describeSecurityPolicies(
        new DescribeSecurityPoliciesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<SecurityPolicy> 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DescribeSecurityPoliciesResult> asyncResult = null;
yield return client.DescribeSecurityPolicies(
    new Gs2.Gs2Identifier.Request.DescribeSecurityPoliciesRequest()
        .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 Gs2Identifier from '@/gs2/identifier';

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

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

from gs2 import core
from gs2 import identifier

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

try:
    result = client.describe_security_policies(
        identifier.DescribeSecurityPoliciesRequest()
            .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('identifier')

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

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

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

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

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->describeCommonSecurityPolicies(
        (new DescribeCommonSecurityPoliciesRequest())
            ->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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DescribeCommonSecurityPoliciesRequest;
import io.gs2.identifier.result.DescribeCommonSecurityPoliciesResult;

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

try {
    DescribeCommonSecurityPoliciesResult result = client.describeCommonSecurityPolicies(
        new DescribeCommonSecurityPoliciesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<SecurityPolicy> 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DescribeCommonSecurityPoliciesResult> asyncResult = null;
yield return client.DescribeCommonSecurityPolicies(
    new Gs2.Gs2Identifier.Request.DescribeCommonSecurityPoliciesRequest()
        .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 Gs2Identifier from '@/gs2/identifier';

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

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

from gs2 import core
from gs2 import identifier

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

try:
    result = client.describe_common_security_policies(
        identifier.DescribeCommonSecurityPoliciesRequest()
            .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('identifier')

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

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

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

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

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->createSecurityPolicy(
        (new CreateSecurityPolicyRequest())
            ->withName("policy-0001")
            ->withDescription(null)
            ->withPolicy("{}")
    );
    $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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.CreateSecurityPolicyRequest;
import io.gs2.identifier.result.CreateSecurityPolicyResult;

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

try {
    CreateSecurityPolicyResult result = client.createSecurityPolicy(
        new CreateSecurityPolicyRequest()
            .withName("policy-0001")
            .withDescription(null)
            .withPolicy("{}")
    );
    SecurityPolicy 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.CreateSecurityPolicyResult> asyncResult = null;
yield return client.CreateSecurityPolicy(
    new Gs2.Gs2Identifier.Request.CreateSecurityPolicyRequest()
        .WithName("policy-0001")
        .WithDescription(null)
        .WithPolicy("{}"),
    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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.createSecurityPolicy(
        new Gs2Identifier.CreateSecurityPolicyRequest()
            .withName("policy-0001")
            .withDescription(null)
            .withPolicy("{}")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.create_security_policy(
        identifier.CreateSecurityPolicyRequest()
            .with_name('policy-0001')
            .with_description(None)
            .with_policy('{}')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.create_security_policy({
    name="policy-0001",
    description=nil,
    policy="{}",
})

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

api_result_handler = client.create_security_policy_async({
    name="policy-0001",
    description=nil,
    policy="{}",
})

api_result = 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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\UpdateSecurityPolicyRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->updateSecurityPolicy(
        (new UpdateSecurityPolicyRequest())
            ->withSecurityPolicyName("policy-0001")
            ->withDescription("description1")
            ->withPolicy("{\"hoge\": \"fuga\"}")
    );
    $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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.UpdateSecurityPolicyRequest;
import io.gs2.identifier.result.UpdateSecurityPolicyResult;

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

try {
    UpdateSecurityPolicyResult result = client.updateSecurityPolicy(
        new UpdateSecurityPolicyRequest()
            .withSecurityPolicyName("policy-0001")
            .withDescription("description1")
            .withPolicy("{\"hoge\": \"fuga\"}")
    );
    SecurityPolicy 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.UpdateSecurityPolicyResult> asyncResult = null;
yield return client.UpdateSecurityPolicy(
    new Gs2.Gs2Identifier.Request.UpdateSecurityPolicyRequest()
        .WithSecurityPolicyName("policy-0001")
        .WithDescription("description1")
        .WithPolicy("{\"hoge\": \"fuga\"}"),
    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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.updateSecurityPolicy(
        new Gs2Identifier.UpdateSecurityPolicyRequest()
            .withSecurityPolicyName("policy-0001")
            .withDescription("description1")
            .withPolicy("{\"hoge\": \"fuga\"}")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.update_security_policy(
        identifier.UpdateSecurityPolicyRequest()
            .with_security_policy_name('policy-0001')
            .with_description('description1')
            .with_policy('{"hoge": "fuga"}')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.update_security_policy({
    securityPolicyName="policy-0001",
    description="description1",
    policy="{\"hoge\": \"fuga\"}",
})

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

api_result_handler = client.update_security_policy_async({
    securityPolicyName="policy-0001",
    description="description1",
    policy="{\"hoge\": \"fuga\"}",
})

api_result = 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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\GetSecurityPolicyRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->getSecurityPolicy(
        (new GetSecurityPolicyRequest())
            ->withSecurityPolicyName("policy-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.GetSecurityPolicyRequest;
import io.gs2.identifier.result.GetSecurityPolicyResult;

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

try {
    GetSecurityPolicyResult result = client.getSecurityPolicy(
        new GetSecurityPolicyRequest()
            .withSecurityPolicyName("policy-0001")
    );
    SecurityPolicy 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.GetSecurityPolicyResult> asyncResult = null;
yield return client.GetSecurityPolicy(
    new Gs2.Gs2Identifier.Request.GetSecurityPolicyRequest()
        .WithSecurityPolicyName("policy-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.getSecurityPolicy(
        new Gs2Identifier.GetSecurityPolicyRequest()
            .withSecurityPolicyName("policy-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.get_security_policy(
        identifier.GetSecurityPolicyRequest()
            .with_security_policy_name('policy-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.get_security_policy({
    securityPolicyName="policy-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('identifier')

api_result_handler = client.get_security_policy_async({
    securityPolicyName="policy-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\DeleteSecurityPolicyRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->deleteSecurityPolicy(
        (new DeleteSecurityPolicyRequest())
            ->withSecurityPolicyName("policy-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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.DeleteSecurityPolicyRequest;
import io.gs2.identifier.result.DeleteSecurityPolicyResult;

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

try {
    DeleteSecurityPolicyResult result = client.deleteSecurityPolicy(
        new DeleteSecurityPolicyRequest()
            .withSecurityPolicyName("policy-0001")
    );
    SecurityPolicy 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.DeleteSecurityPolicyResult> asyncResult = null;
yield return client.DeleteSecurityPolicy(
    new Gs2.Gs2Identifier.Request.DeleteSecurityPolicyRequest()
        .WithSecurityPolicyName("policy-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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.deleteSecurityPolicy(
        new Gs2Identifier.DeleteSecurityPolicyRequest()
            .withSecurityPolicyName("policy-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.delete_security_policy(
        identifier.DeleteSecurityPolicyRequest()
            .with_security_policy_name('policy-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.delete_security_policy({
    securityPolicyName="policy-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('identifier')

api_result_handler = client.delete_security_policy_async({
    securityPolicyName="policy-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\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\LoginRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->login(
        (new LoginRequest())
            ->withClientId("client-0001")
            ->withClientSecret("secret-0001")
    );
    $accessToken = $result->getAccessToken();
    $tokenType = $result->getTokenType();
    $expiresIn = $result->getExpiresIn();
    $ownerId = $result->getOwnerId();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.LoginRequest;
import io.gs2.identifier.result.LoginResult;

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

try {
    LoginResult result = client.login(
        new LoginRequest()
            .withClientId("client-0001")
            .withClientSecret("secret-0001")
    );
    String accessToken = result.getAccessToken();
    String tokenType = result.getTokenType();
    int expiresIn = result.getExpiresIn();
    String ownerId = result.getOwnerId();
} 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.LoginResult> asyncResult = null;
yield return client.Login(
    new Gs2.Gs2Identifier.Request.LoginRequest()
        .WithClientId("client-0001")
        .WithClientSecret("secret-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var accessToken = result.AccessToken;
var tokenType = result.TokenType;
var expiresIn = result.ExpiresIn;
var ownerId = result.OwnerId;

import Gs2Core from '@/gs2/core';
import * as Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.login(
        new Gs2Identifier.LoginRequest()
            .withClientId("client-0001")
            .withClientSecret("secret-0001")
    );
    const accessToken = result.getAccessToken();
    const tokenType = result.getTokenType();
    const expiresIn = result.getExpiresIn();
    const ownerId = result.getOwnerId();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.login(
        identifier.LoginRequest()
            .with_client_id('client-0001')
            .with_client_secret('secret-0001')
    )
    access_token = result.access_token
    token_type = result.token_type
    expires_in = result.expires_in
    owner_id = result.owner_id
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.login({
    clientId="client-0001",
    clientSecret="secret-0001",
})

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

result = api_result.result
accessToken = result.accessToken;
tokenType = result.tokenType;
expiresIn = result.expiresIn;
ownerId = result.ownerId;

client = gs2('identifier')

api_result_handler = client.login_async({
    clientId="client-0001",
    clientSecret="secret-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
accessToken = result.accessToken;
tokenType = result.tokenType;
expiresIn = result.expiresIn;
ownerId = result.ownerId;

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Identifier\Gs2IdentifierRestClient;
use Gs2\Identifier\Request\LoginByUserRequest;

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

$session->open();

$client = new Gs2IdentifierRestClient(
    $session
);

try {
    $result = $client->loginByUser(
        (new LoginByUserRequest())
            ->withUserName("user-name")
            ->withPassword("password")
            ->withOtp(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.identifier.rest.Gs2IdentifierRestClient;
import io.gs2.identifier.request.LoginByUserRequest;
import io.gs2.identifier.result.LoginByUserResult;

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

try {
    LoginByUserResult result = client.loginByUser(
        new LoginByUserRequest()
            .withUserName("user-name")
            .withPassword("password")
            .withOtp(null)
    );
    ProjectToken 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 Gs2IdentifierRestClient(session);

AsyncResult<Gs2.Gs2Identifier.Result.LoginByUserResult> asyncResult = null;
yield return client.LoginByUser(
    new Gs2.Gs2Identifier.Request.LoginByUserRequest()
        .WithUserName("user-name")
        .WithPassword("password")
        .WithOtp(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 Gs2Identifier from '@/gs2/identifier';

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

try {
    const result = await client.loginByUser(
        new Gs2Identifier.LoginByUserRequest()
            .withUserName("user-name")
            .withPassword("password")
            .withOtp(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import identifier

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

try:
    result = client.login_by_user(
        identifier.LoginByUserRequest()
            .with_user_name('user-name')
            .with_password('password')
            .with_otp(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('identifier')

api_result = client.login_by_user({
    userName="user-name",
    password="password",
    otp=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('identifier')

api_result_handler = client.login_by_user_async({
    userName="user-name",
    password="password",
    otp=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;