> For the complete documentation index, see [llms.txt](/llms.txt)

# GS2-Grade SDK API リファレンス

各種プログラミング言語向け GS2-Grade SDK の モデルの仕様 と API のリファレンス



## モデル

### Namespace

ネームスペース<br>

ネームスペースは、一つのプロジェクト内で同じサービスを異なる用途で複数利用するためのエンティティです。<br>
GS2 の各サービスはネームスペース単位で管理されます。ネームスペースが異なれば、同じサービスでも完全に独立したデータ空間として扱われます。<br>

そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string |  | ※ |  |  ~ 1024文字 | ネームスペースGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  |  |  |  ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) |  |  |  |  | トランザクション設定<br>グレード操作時の分散トランザクションの実行方法を制御する設定です。自動実行、アトミックコミット、非同期処理などのオプションをサポートします。 |
| changeGradeScript | [ScriptSetting](#scriptsetting) |  |  |  |  | グレードが変化したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`changeGrade`](../script/#changegrade) |
| logSetting | [LogSetting](#logsetting) |  |  |  |  | ログの出力設定<br>グレード操作のログデータを GS2-Log に出力するための設定です。GS2-Log のネームスペースを指定することで、グレード変更やランクキャップ更新の API リクエスト・レスポンスログを収集できます。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeNamespaces - ネームスペースの一覧を取得
createNamespace - ネームスペースを新規作成
getNamespace - ネームスペースを取得
updateNamespace - ネームスペースを更新
deleteNamespace - ネームスペースを削除




---

### TransactionSetting

トランザクション設定<br>

トランザクション設定は、トランザクションの実行方法・整合性・非同期処理・競合回避の仕組みを制御する設定です。<br>
自動実行（AutoRun）、アトミック実行（AtomicCommit）、GS2-Distributor を利用した非同期実行、スクリプト結果の一括適用、GS2-JobQueue による入手アクションの非同期化などを組み合わせ、ゲームロジックに応じた堅牢なトランザクション管理を可能にします。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| enableAutoRun | bool |  |  | false |  | 発行したトランザクションをサーバーサイドで自動的に実行するか |
| enableAtomicCommit | bool | {enableAutoRun} == true |  | false |  | トランザクションの実行をアトミックにコミットするか<br>※ enableAutoRun が true であれば 有効 |
| transactionUseDistributor | bool | {enableAtomicCommit} == true |  | false |  | トランザクションを非同期処理で実行する<br>※ enableAtomicCommit が true であれば 有効 |
| commitScriptResultInUseDistributor | bool | {transactionUseDistributor} == true |  | false |  | スクリプトの結果コミット処理を非同期処理で実行するか<br>※ transactionUseDistributor が true であれば 有効 |
| acquireActionUseJobQueue | bool | {enableAtomicCommit} == true |  | false |  | 入手アクションを実行する際に GS2-JobQueue を使用するか<br>※ enableAtomicCommit が true であれば 有効 |
| distributorNamespaceId | string |  |  | "grn:gs2:{region}:{ownerId}:distributor:default" |  ~ 1024文字 | トランザクションの実行に使用する GS2-Distributor ネームスペースGRN |
| queueNamespaceId | string |  |  | "grn:gs2:{region}:{ownerId}:queue:default" |  ~ 1024文字 | トランザクションの実行に使用する GS2-JobQueue のネームスペースGRN |

**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新


**関連するモデル:**
Namespace - ネームスペース




---

### ScriptSetting

スクリプト設定<br>

GS2 ではマイクロサービスのイベントに関連づけて、カスタムスクリプトを実行することができます。<br>
このモデルは、スクリプトの実行をトリガーするための設定を保持します。<br>

スクリプトの実行方式は大きく2種類あり、それは「同期実行」と「非同期実行」です。<br>
同期実行は、スクリプトの実行が完了するまで処理がブロックされます。<br>
代わりに、スクリプトの実行結果を使って API の実行を止めたり、API のレスポンス内容を制御することができます。<br>

一方、非同期実行ではスクリプトの完了を待つために処理がブロックされることはありません。<br>
ただし、スクリプトの実行結果を利用して API の実行を停止したり、API の応答内容を変更することはできません。<br>
非同期実行は API の応答フローに影響を与えないため、原則として非同期実行を推奨します。<br>

非同期実行には実行方式が2種類あり、GS2-Script と Amazon EventBridge があります。<br>
Amazon EventBridge を使用することで、Lua 以外の言語で処理を記述することができます。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| triggerScriptId | string |  |  |  |  ~ 1024文字 | API 実行時に同期的に実行される GS2-Script のスクリプトGRN<br>「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。 |
| doneTriggerTargetType | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"none",<br>&nbsp;&nbsp;"gs2_script",<br>&nbsp;&nbsp;"aws"<br>}<br> |  |  | "none" |  | 非同期スクリプトの実行方法<br>非同期実行で使用するスクリプトの種類を指定します。<br>「非同期実行のスクリプトを使用しない(none)」「GS2-Scriptを使用する(gs2_script)」「Amazon EventBridgeを使用する(aws)」が選択できます。"none": なし / "gs2_script": GS2-Script / "aws": Amazon EventBridge /  |
| doneTriggerScriptId | string | {doneTriggerTargetType} == "gs2_script" |  |  |  ~ 1024文字 | 非同期実行する GS2-Script スクリプトGRN<br>「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。<br>※ doneTriggerTargetType が "gs2_script" であれば 有効 |
| doneTriggerQueueNamespaceId | string | {doneTriggerTargetType} == "gs2_script" |  |  |  ~ 1024文字 | 非同期実行スクリプトを実行する GS2-JobQueue ネームスペースGRN<br>非同期実行スクリプトを直接実行するのではなく、GS2-JobQueue を経由する場合は GS2-JobQueue のネームスペースGRN を指定します。<br>GS2-JobQueue を利用する理由は多くはありませんので、特に理由がなければ指定する必要はありません。<br>※ doneTriggerTargetType が "gs2_script" であれば 有効 |

**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新


**関連するモデル:**
Namespace - ネームスペース




---

### LogSetting

ログの出力設定<br>

ログデータの出力設定を管理します。この型は、ログデータを書き出すために使用される GS2-Log ネームスペースの識別子（Namespace ID）を保持します。<br>
ログネームスペースID(loggingNamespaceId)には、ログデータを収集し保存する GS2-Log のネームスペースを、GRNの形式で指定します。<br>
この設定をすることで、設定されたネームスペース内で発生したAPIリクエスト・レスポンスのログデータが、対象の GS2-Log ネームスペース側へ出力されるようになります。<br>
GS2-Log ではリアルタイムでログが提供され、システムの監視や分析、デバッグなどに利用できます。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| loggingNamespaceId | string |  | ✓ |  |  ~ 1024文字 | ログを出力する GS2-Log のネームスペースGRN<br>「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。 |

**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新


**関連するモデル:**
Namespace - ネームスペース




---

### GitHubCheckoutSetting

GitHubからマスターデータをチェックアウトする設定



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string |  | ✓ |  |  ~ 1024文字 | GitHub APIキーのGRN |
| repositoryName | string |  | ✓ |  |  ~ 1024文字 | リポジトリ名 |
| sourcePath | string |  | ✓ |  |  ~ 1024文字 | マスターデータ（JSON）ファイルのパス |
| referenceType | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"commit_hash",<br>&nbsp;&nbsp;"branch",<br>&nbsp;&nbsp;"tag"<br>}<br> |  | ✓ |  |  | コードの取得元"commit_hash": コミットハッシュ / "branch": ブランチ / "tag": タグ /  |
| commitHash | string | {referenceType} == "commit_hash" | ✓※ |  |  ~ 1024文字 | コミットハッシュ<br>※ referenceType が "commit_hash" であれば 必須 |
| branchName | string | {referenceType} == "branch" | ✓※ |  |  ~ 1024文字 | ブランチ名<br>※ referenceType が "branch" であれば 必須 |
| tagName | string | {referenceType} == "tag" | ✓※ |  |  ~ 1024文字 | タグ名<br>※ referenceType が "tag" であれば 必須 |

**関連するメソッド:**
updateCurrentGradeMasterFromGitHub - 現在アクティブなグレードモデルのマスターデータをGitHubから更新




---

### Status

ステータス<br>

ステータスとはプロパティID毎に存在するエンティティで、<br>
現在のグレードの値を保持します。<br>

プロパティID とはステータス固有のIDで、開発者が任意の値を設定できます。<br>
連動する GS2-Experience のプロパティIDと完全に一致する値を使用することを強く推奨しています。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| statusId | string |  | ※ |  |  ~ 1024文字 | ステータスGRN<br>※ サーバーが自動で設定 |
| gradeName | string |  | ✓ |  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| userId | string |  | ✓ |  |  ~ 128文字 | ユーザーID |
| propertyId | string |  | ✓ |  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| gradeValue | long |  |  | 1 | 1 ~ 9223372036854775805 | 現在のグレード<br>このステータスの現在のグレード値です。連動する GS2-Experience モデルのランクキャップを決定するために、グレードモデルのグレードエントリ配列のインデックスとして使用されます。この値が変更されると、関連する経験値ステータスのランクキャップが対応するグレードエントリで定義された値に自動更新されます。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeStatuses - ステータスの一覧を取得
describeStatusesByUserId - ユーザーIDを指定してステータスの一覧を取得
getStatus - ステータスを取得
getStatusByUserId - ユーザーIDを指定してステータスを取得
addGradeByUserId - ユーザーIDを指定してグレードを加算
subGrade - グレードを減算
subGradeByUserId - ユーザーIDを指定してグレードを減算
setGradeByUserId - 累計獲得グレードを設定
applyRankCap - GS2-Experienceステータスにランクキャップを適用
applyRankCapByUserId - ユーザーIDを指定して GS2-Experienceステータスにランクキャップを適用
deleteStatusByUserId - ユーザーIDを指定してステータスを削除
verifyGrade - グレードを検証
verifyGradeByUserId - ユーザーIDを指定してグレードを検証




---

### GradeModel

グレードモデル<br>

グレードモデルとは、キャラクターや装備のランクを示すエンティティで、グレードによって GS2-Experience のランクキャップを設定することができます。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| gradeModelId | string |  | ※ |  |  ~ 1024文字 | グレードモデルGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | グレードモデル名<br>グレードモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string |  |  |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| defaultGrades | [List&lt;DefaultGradeModel&gt;](#defaultgrademodel) |  |  |  | 0 ~ 100 items | デフォルトグレードモデルリスト<br>新規ステータス作成時に評価されるデフォルトグレードルールの順序付きリストです。各エントリはプロパティIDの正規表現パターンとマッチした場合に割り当てるグレード値を定義します。どのパターンにもマッチしない場合はデフォルトのグレード値 0 が使用されます。 |
| experienceModelId | string |  | ✓ |  |  ~ 1024文字 | GS2-Experience 経験値モデルGRN<br>このグレードモデルと連動させる GS2-Experience の経験値モデルの GRN です。グレード値が変更されると、グレードエントリのマッピングに基づいて連動する経験値モデルのランクキャップが自動的に更新されます。これにより、高いグレードが高いランクキャップを解放するグレード駆動の成長が実現できます。 |
| gradeEntries | [List&lt;GradeEntryModel&gt;](#gradeentrymodel) |  | ✓ |  | 1 ~ 100 items | グレードエントリーモデルリスト<br>各グレード値を連動する GS2-Experience モデルのランクキャップにマッピングするグレードエントリの順序付きリストです。配列のインデックスがグレード値に対応し、最初のエントリ（インデックス 0）がグレード 0 のランクキャップを、2番目がグレード 1 を定義します。 |
| acquireActionRates | [List&lt;AcquireActionRate&gt;](#acquireactionrate) |  |  |  | 0 ~ 100 items | 報酬加算テーブルリスト<br>グレードに基づいて報酬量をスケーリングするための名前付き倍率テーブルのコレクションです。複数のテーブルを定義して、異なる種類の報酬（例: 経験値、通貨、アイテム）に異なるスケーリングルールを適用できます。 |

**関連するメソッド:**
describeGradeModels - グレードモデルの一覧を取得
getGradeModel - グレードモデルを取得




---

### DefaultGradeModel

デフォルトグレードモデル<br>

グレードを新規作成する際にプロパティIDの正規表現へのマッチに応じてデフォルトのグレード値を設定することができます。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| propertyIdRegex | string |  | ✓ |  |  ~ 1024文字 | プロパティID正規表現<br>新規作成されたグレードステータスのプロパティIDに対してマッチングされる正規表現パターンです。プロパティIDがこのパターンにマッチすると、0 の代わりに指定されたデフォルトグレード値が初期グレードとして割り当てられます。パターンは順番に評価され、最初にマッチしたものが使用されます。 |
| defaultGradeValue | long |  | ✓ |  | 0 ~ 9223372036854775805 | デフォルトのグレード値<br>プロパティIDが propertyIdRegex パターンにマッチした場合に新規作成されたステータスに割り当てられる初期グレード値です。このインデックスのグレードエントリが対応するランクキャップを定義するため、この値は連動する GS2-Experience モデルの開始ランクキャップを決定します。 |

**関連するモデル:**
GradeModel - グレードモデル
GradeModelMaster - グレードモデルマスター




---

### GradeEntryModel

グレードエントリーモデル<br>

グレード値と連動する GS2-Experience モデルのランクキャップのマッピングを定義します。各エントリはプロパティIDのマッチングに使用する正規表現パターンも指定し、グレードアップ操作に使用できるリソースとそのプロパティIDの変換方法を決定します。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| metadata | string |  |  |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| rankCapValue | long |  | ✓ |  | 0 ~ 9223372036854775805 | ランクキャップ値<br>このグレードが適用された際に連動する GS2-Experience モデルに設定するランクキャップ値です。プレイヤーのグレードがこのエントリに対応する値に変更されると、関連する経験値ステータスのランクキャップがこの値に自動更新され、到達可能な最大ランクが制御されます。 |
| propertyIdRegex | string |  | ✓ |  |  ~ 1024文字 | プロパティID正規表現<br>グレードアップマッチング用の変数を抽出するために、グレードステータスのプロパティIDに適用される正規表現パターンです。このパターン内のキャプチャグループ（括弧で囲まれた部分）は gradeUpPropertyIdRegex で $1、$2 などとして利用できます。例えば "character-(.+)" というパターンはキャラクター識別子を抽出し、グレードアップ素材のプロパティIDマッチングに使用します。 |
| gradeUpPropertyIdRegex | string |  | ✓ |  |  ~ 1024文字 | グレードアップ用プロパティID正規表現<br>グレード昇格のために消費できるリソースのプロパティIDを特定する正規表現パターンです。このパターンは propertyIdRegex のキャプチャグループを $1、$2 などで参照できます。例えば propertyIdRegex で "sword-001" を $1 として抽出した場合、このパターンを "grade-up-material-$1" とすることで、その剣に固有の素材をマッチさせることができます。 |

**関連するモデル:**
GradeModel - グレードモデル
GradeModelMaster - グレードモデルマスター




---

### AcquireActionRate

報酬加算テーブル<br>

現在のグレード値に基づいて報酬量をスケーリングする名前付き倍率テーブルを定義します。各グレード値は入手アクションに適用される倍率にマッピングされ、高いグレードのキャラクターや装備がより多くの報酬を受け取れるようになります。標準的な倍精度浮動小数点数モードと、非常に大きな値に対応するビッグナンバーモードの両方をサポートします。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string |  | ✓ |  |  ~ 128文字 | 報酬加算テーブル名<br>グレードモデル内でこの倍率テーブルを一意に識別する名前です。トランザクションの特定の入手アクションにグレードベースの報酬スケーリングを適用する際に参照されます。 |
| mode | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"double",<br>&nbsp;&nbsp;"big"<br>}<br> |  |  | "double" |  | 報酬加算テーブルの種類<br>倍率値の数値精度モードを選択します。"double" モードはほとんどのケースに適した標準的な浮動小数点数を使用します。"big" モードは最大1024桁までの文字列表現の数値を使用し、非常に大きな値の計算を必要とするゲームに対応します。"double": 2^48 未満の浮動小数点数 / "big": 文字列表記で1024桁未満の浮動小数点数 /  |
| rates | List&lt;double&gt; | {mode} == "double" | ✓※ |  | 1 ~ 1000 items | グレードごとの倍率リスト（double モード）<br>グレード値でインデックスされた報酬倍率の配列で、倍精度浮動小数点数を使用します。インデックス 0 のエントリがグレード 0 の倍率、インデックス 1 がグレード 1 の倍率となります。mode が "double" に設定されている場合に使用されます。<br>※ mode が "double" であれば 必須 |
| bigRates | List&lt;string&gt; | {mode} == "big" | ✓※ |  | 1 ~ 1000 items | グレードごとの倍率リスト（big モード）<br>グレード値でインデックスされた報酬倍率の配列で、拡張精度のために文字列表現の数値を使用します。インデックス 0 のエントリがグレード 0 の倍率、インデックス 1 がグレード 1 の倍率となります。非常に大きな数値計算を必要とするゲーム向けに、mode が "big" に設定されている場合に使用されます。<br>※ mode が "big" であれば 必須 |

**関連するモデル:**
GradeModel - グレードモデル
GradeModelMaster - グレードモデルマスター




---

### AcquireAction

入手アクション



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型<br>enum {<br>}<br> |  | ✓ |  |  | 入手アクションで実行するアクションの種類 |
| request | string |  | ✓ |  |  ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |

**関連するメソッド:**
multiplyAcquireActionsByUserId - グレードに基づくレートで入手アクションを乗算




---

### VerifyActionResult

検証アクションの実行結果



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型<br>enum {<br>}<br> |  | ✓ |  |  | 検証アクションで実行するアクションの種類 |
| verifyRequest | string |  | ✓ |  |  ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int |  |  |  | 0 ~ 999 | ステータスコード |
| verifyResult | string |  |  |  |  ~ 1048576文字 | 結果内容 |

**関連するモデル:**
TransactionResult - トランザクション実行結果




---

### ConsumeActionResult

消費アクションの実行結果



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型<br>enum {<br>}<br> |  | ✓ |  |  | 消費アクションで実行するアクションの種類 |
| consumeRequest | string |  | ✓ |  |  ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int |  |  |  | 0 ~ 999 | ステータスコード |
| consumeResult | string |  |  |  |  ~ 1048576文字 | 結果内容 |

**関連するモデル:**
TransactionResult - トランザクション実行結果




---

### AcquireActionResult

入手アクションの実行結果



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型<br>enum {<br>}<br> |  | ✓ |  |  | 入手アクションで実行するアクションの種類 |
| acquireRequest | string |  | ✓ |  |  ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int |  |  |  | 0 ~ 999 | ステータスコード |
| acquireResult | string |  |  |  |  ~ 1048576文字 | 結果内容 |

**関連するモデル:**
TransactionResult - トランザクション実行結果




---

### TransactionResult

トランザクション実行結果<br>

サーバーサイドでのトランザクションの自動実行機能を利用して実行されたトランザクションの実行結果



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| transactionId | string |  | ✓ |  | 36 ~ 36文字 | トランザクションID |
| verifyResults | [List&lt;VerifyActionResult&gt;](#verifyactionresult) |  |  |  | 0 ~ 10 items | 検証アクションの実行結果リスト |
| consumeResults | [List&lt;ConsumeActionResult&gt;](#consumeactionresult) |  |  | [] | 0 ~ 10 items | 消費アクションの実行結果リスト |
| acquireResults | [List&lt;AcquireActionResult&gt;](#acquireactionresult) |  |  | [] | 0 ~ 100 items | 入手アクションの実行結果リスト |
| hasError | bool |  |  | false |  | トランザクション実行中にエラーが発生したかどうか |

**関連するメソッド:**
multiplyAcquireActionsByUserId - グレードに基づくレートで入手アクションを乗算




---

### CurrentGradeMaster

現在アクティブなグレードモデルのマスターデータ<br>

現在ネームスペース内で有効な、グレードモデルの定義を記述したマスターデータです。<br>
GS2ではマスターデータの管理にJSON形式のファイルを使用します。<br>
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。<br>

JSONファイルを作成する方法として、マネージメントコンソール内にマスターデータエディタを提供しています。<br>
また、よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。
{{% alert title="Note" color="info" %}}
JSONファイルの形式については [GS2-Grade マスターデータリファレンス](api_reference/grade/master_data/) をご参照ください。
{{% /alert %}}



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string |  | ※ |  |  ~ 1024文字 | ネームスペースGRN<br>※ サーバーが自動で設定 |
| settings | string |  | ✓ |  |  ~ 5242880 バイト (5MB) | マスターデータ |

**関連するメソッド:**
exportMaster - グレードモデルマスターを有効化可能なマスターデータ形式でエクスポート
getCurrentGradeMaster - 現在アクティブなグレードモデルのマスターデータを取得
updateCurrentGradeMaster - 現在アクティブなグレードモデルのマスターデータを更新
updateCurrentGradeMasterFromGitHub - 現在アクティブなグレードモデルのマスターデータをGitHubから更新




---

### GradeModelMaster

グレードモデルマスター<br>

グレードモデルマスターは、ゲーム内で使用されるグレードモデルの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。<br>
インポート・更新処理を行うことで、実際にゲームから参照されるグレードモデルとして反映されます。<br>

グレードモデルとは、キャラクターや装備のランクを示すエンティティで、グレードによって GS2-Experience のランクキャップを設定することができます。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| gradeModelId | string |  | ※ |  |  ~ 1024文字 | グレードモデルマスターGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | グレードモデル名 |
| description | string |  |  |  |  ~ 1024文字 | 説明文 |
| metadata | string |  |  |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| defaultGrades | [List&lt;DefaultGradeModel&gt;](#defaultgrademodel) |  |  |  | 0 ~ 100 items | デフォルトグレードモデルリスト<br>新規ステータス作成時に評価されるデフォルトグレードルールの順序付きリストです。各エントリはプロパティIDの正規表現パターンとマッチした場合に割り当てるグレード値を定義します。どのパターンにもマッチしない場合はデフォルトのグレード値 0 が使用されます。 |
| experienceModelId | string |  | ✓ |  |  ~ 1024文字 | GS2-Experience 経験値モデルGRN<br>このグレードモデルと連動させる GS2-Experience の経験値モデルの GRN です。グレード値が変更されると、グレードエントリのマッピングに基づいて連動する経験値モデルのランクキャップが自動的に更新されます。これにより、高いグレードが高いランクキャップを解放するグレード駆動の成長が実現できます。 |
| gradeEntries | [List&lt;GradeEntryModel&gt;](#gradeentrymodel) |  |  |  | 0 ~ 100 items | グレードエントリーモデルリスト<br>各グレード値を連動する GS2-Experience モデルのランクキャップにマッピングするグレードエントリの順序付きリストです。配列のインデックスがグレード値に対応し、最初のエントリ（インデックス 0）がグレード 0 のランクキャップを、2番目がグレード 1 を定義します。 |
| acquireActionRates | [List&lt;AcquireActionRate&gt;](#acquireactionrate) |  |  |  | 0 ~ 100 items | 報酬加算テーブルリスト<br>グレードに基づいて報酬量をスケーリングするための名前付き倍率テーブルのコレクションです。複数のテーブルを定義して、異なる種類の報酬（例: 経験値、通貨、アイテム）に異なるスケーリングルールを適用できます。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeGradeModelMasters - グレードモデルマスターの一覧を取得
createGradeModelMaster - グレードモデルマスターを新規作成
getGradeModelMaster - グレードモデルマスターを取得
updateGradeModelMaster - グレードモデルマスターを更新
deleteGradeModelMaster - グレードモデルマスターを削除




---
## メソッド

### describeNamespaces

ネームスペースの一覧を取得<br>

プロジェクト内において、サービス単位で作成されたネームスペースの一覧を取得します。<br>
オプションのページトークンを使用して、リストの特定の位置からデータの取得を開始できます。<br>
また、取得するネームスペースの数を制限することも可能です。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namePrefix | string |  | |  |  ~ 64文字 | ネームスペース名のフィルター接頭辞 |
| pageToken | string |  | |  |  ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int |  | | 30 | 1 ~ 1000 | データの取得件数 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;Namespace&gt;](#namespace) | ネームスペースのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DescribeNamespacesRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

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

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

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

```




---

### createNamespace

ネームスペースを新規作成<br>

ネームスペースの名前、説明、および各種設定を含む詳細情報を指定する必要があります。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) |  | |  |  | トランザクション設定<br>グレード操作時の分散トランザクションの実行方法を制御する設定です。自動実行、アトミックコミット、非同期処理などのオプションをサポートします。 |
| changeGradeScript | [ScriptSetting](#scriptsetting) |  | |  |  | グレードが変化したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`changeGrade`](../script/#changegrade) |
| logSetting | [LogSetting](#logsetting) |  | |  |  | ログの出力設定<br>グレード操作のログデータを GS2-Log に出力するための設定です。GS2-Log のネームスペースを指定することで、グレード変更やランクキャップ更新の API リクエスト・レスポンスログを収集できます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 作成したネームスペース |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName("namespace-0001")
            ->withDescription(null)
            ->withTransactionSetting(null)
            ->withChangeGradeScript(null)
            ->withLogSetting((new \Gs2\Grade\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.CreateNamespaceRequest;
import io.gs2.grade.result.CreateNamespaceResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Grade.Request.CreateNamespaceRequest()
        .WithName("namespace-0001")
        .WithDescription(null)
        .WithTransactionSetting(null)
        .WithChangeGradeScript(null)
        .WithLogSetting(new Gs2.Gs2Grade.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.createNamespace(
        new Gs2Grade.CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(null)
            .withChangeGradeScript(null)
            .withLogSetting(new Gs2Grade.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.create_namespace(
        grade.CreateNamespaceRequest()
            .with_name('namespace-0001')
            .with_description(None)
            .with_transaction_setting(None)
            .with_change_grade_script(None)
            .with_log_setting(
                grade.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
item = result.item;

```




---

### getNamespaceStatus

ネームスペースの状態を取得<br>

指定されたネームスペースの現在の状態を取得します。<br>
これには、ネームスペースがアクティブか、保留中か、またはその他の状態にあるかが含まれます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| status | string |  |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetNamespaceStatusRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName("namespace-0001")
    );
    $status = $result->getStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetNamespaceStatusRequest;
import io.gs2.grade.result.GetNamespaceStatusResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2Grade.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
status = result.status;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
status = result.status;

```




---

### getNamespace

ネームスペースを取得<br>

指定されたネームスペースの詳細情報を取得します。<br>
これには、ネームスペースの名前、説明、およびその他の設定情報が含まれます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | ネームスペース |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetNamespaceRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetNamespaceRequest;
import io.gs2.grade.result.GetNamespaceResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2Grade.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
item = result.item;

```




---

### updateNamespace

ネームスペースを更新<br>

指定されたネームスペースの設定を更新します。<br>
ネームスペースの説明や、特定の設定を変更することができます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) |  | |  |  | トランザクション設定<br>グレード操作時の分散トランザクションの実行方法を制御する設定です。自動実行、アトミックコミット、非同期処理などのオプションをサポートします。 |
| changeGradeScript | [ScriptSetting](#scriptsetting) |  | |  |  | グレードが変化したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`changeGrade`](../script/#changegrade) |
| logSetting | [LogSetting](#logsetting) |  | |  |  | ログの出力設定<br>グレード操作のログデータを GS2-Log に出力するための設定です。GS2-Log のネームスペースを指定することで、グレード変更やランクキャップ更新の API リクエスト・レスポンスログを収集できます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 更新したネームスペース |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &grade.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Description: pointy.String("description1"),
        TransactionSetting: nil,
        ChangeGradeScript: &grade.ScriptSetting{
            TriggerScriptId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1002"),
            DoneTriggerScriptId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1003"),
        },
        LogSetting: &grade.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName("namespace-0001")
            ->withDescription("description1")
            ->withTransactionSetting(null)
            ->withChangeGradeScript((new \Gs2\Grade\Model\ScriptSetting())
                ->withTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1002")
                ->withDoneTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1003"))
            ->withLogSetting((new \Gs2\Grade\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.UpdateNamespaceRequest;
import io.gs2.grade.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(null)
            .withChangeGradeScript(new io.gs2.grade.model.ScriptSetting()
                .withTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1002")
                .withDoneTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1003"))
            .withLogSetting(new io.gs2.grade.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Grade.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace-0001")
        .WithDescription("description1")
        .WithTransactionSetting(null)
        .WithChangeGradeScript(new Gs2.Gs2Grade.Model.ScriptSetting()
            .WithTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1002")
            .WithDoneTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1003"))
        .WithLogSetting(new Gs2.Gs2Grade.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.updateNamespace(
        new Gs2Grade.UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(null)
            .withChangeGradeScript(new Gs2Grade.model.ScriptSetting()
                .withTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1002")
                .withDoneTriggerScriptId("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1003"))
            .withLogSetting(new Gs2Grade.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.update_namespace(
        grade.UpdateNamespaceRequest()
            .with_namespace_name('namespace-0001')
            .with_description('description1')
            .with_transaction_setting(None)
            .with_change_grade_script(
                grade.ScriptSetting()
                    .with_trigger_script_id('grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1002')
                    .with_done_trigger_script_id('grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script-1003'))
            .with_log_setting(
                grade.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
item = result.item;

```




---

### deleteNamespace

ネームスペースを削除<br>

指定されたネームスペースを削除します。<br>
この操作は不可逆であり、削除されたネームスペースに関連するすべてのデータは回復不能になります。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 削除したネームスペース |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DeleteNamespaceRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.DeleteNamespaceRequest;
import io.gs2.grade.result.DeleteNamespaceResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2Grade.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
item = result.item;

```




---

### getServiceVersion

マイクロサービスのバージョンを取得



#### Request

リクエストパラメータ: なし

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | string | バージョン |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetServiceVersionRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getServiceVersion(
        (new GetServiceVersionRequest())
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetServiceVersionRequest;
import io.gs2.grade.result.GetServiceVersionResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetServiceVersionResult> asyncResult = null;
yield return client.GetServiceVersion(
    new Gs2.Gs2Grade.Request.GetServiceVersionRequest(),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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;

```




---

### dumpUserDataByUserId

指定したユーザーIDに紐づくデータのダンプを取得<br>

個人情報保護の法的要件を満たすために使用したり、データのバックアップや移行に使用できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.DumpUserDataByUserId(
    &grade.DumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result

```




---

### checkDumpUserDataByUserId

指定したユーザーIDに紐づくデータのダンプが完了しているか確認



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| url | string | 出力データのURL |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
    &grade.CheckDumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\CheckDumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
url = result.url;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
url = result.url;

```




---

### cleanUserDataByUserId

ユーザーデータの完全削除<br>

指定されたユーザーIDに紐づくデータのクリーニングを実行します。<br>
これにより、特定のユーザーデータをプロジェクトから安全に削除できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.CleanUserDataByUserId(
    &grade.CleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\CleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result

```




---

### checkCleanUserDataByUserId

指定したユーザーIDのユーザーデータの完全削除が完了しているか確認



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
    &grade.CheckCleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\CheckCleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result

```




---

### prepareImportUserDataByUserId

指定したユーザーIDに紐づくデータのインポートを準備<br>

インポートに使用できるデータは GS2 によってエクスポートして取得したデータに限定され、古いデータはインポートに失敗する可能性があります。<br>
エクスポートしたユーザーIDと異なるユーザーIDでインポートすることができますが、ユーザーデータのペイロード内にユーザーIDが含まれる場合はその限りではありません。<br>

このAPIの戻り値で応答されたURLにエクスポートした zip ファイルをアップロードし、importUserDataByUserId を呼び出すことで実際のインポート処理を開始できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| uploadToken | string | アップロード後に結果を反映する際に使用するトークン |
| uploadUrl | string | ユーザーデータアップロード処理の実行に使用するURL |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
    &grade.PrepareImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\PrepareImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

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

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

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

```




---

### importUserDataByUserId

指定したユーザーIDに紐づくデータのインポートを実行<br>

インポートに使用できるデータは GS2 によってエクスポートして取得したデータに限定され、古いデータはインポートに失敗する可能性があります。<br>
エクスポートしたユーザーIDと異なるユーザーIDでインポートすることができますが、ユーザーデータのペイロード内にユーザーIDが含まれる場合はその限りではありません。<br>

このAPIを呼び出す前に prepareImportUserDataByUserId を呼び出して、アップロード準備を完了させる必要があります。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| uploadToken | string |  | ✓|  |  ~ 1024文字 | アップロード準備で受け取ったトークン |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.ImportUserDataByUserId(
    &grade.ImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\ImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result

```




---

### checkImportUserDataByUserId

指定したユーザーIDに紐づくデータのインポートが完了しているか確認



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| uploadToken | string |  | ✓|  |  ~ 1024文字 | アップロード準備で受け取ったトークン |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| url | string | 出力ログのURL |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
    &grade.CheckImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\CheckImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

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

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
url = result.url;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
url = result.url;

```




---

### describeStatuses

ステータスの一覧を取得<br>

リクエストしたユーザーのグレードステータスのページネーション付きリストを取得します。<br>
各ステータスは特定のグレードモデルとプロパティIDに関連付けられたグレード値を表します。<br>
オプションでグレードモデル名フィルタを指定して、特定のグレードモデルのステータスのみを取得できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gradeName | string |  | |  |  ~ 128文字 | グレードモデル名 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| pageToken | string |  | |  |  ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int |  | | 30 | 1 ~ 1000 | データの取得件数 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;Status&gt;](#status) | ステータスのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.DescribeStatuses(
    &grade.DescribeStatusesRequest {
        NamespaceName: pointy.String("namespace-0001"),
        GradeName: pointy.String("grade-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DescribeStatusesRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->describeStatuses(
        (new DescribeStatusesRequest())
            ->withNamespaceName("namespace-0001")
            ->withGradeName("grade-0001")
            ->withAccessToken("accessToken-0001")
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.DescribeStatusesRequest;
import io.gs2.grade.result.DescribeStatusesResult;

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

try {
    DescribeStatusesResult result = client.describeStatuses(
        new DescribeStatusesRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<Status> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.DescribeStatusesResult> asyncResult = null;
yield return client.DescribeStatuses(
    new Gs2.Gs2Grade.Request.DescribeStatusesRequest()
        .WithNamespaceName("namespace-0001")
        .WithGradeName("grade-0001")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.describeStatuses(
        new Gs2Grade.DescribeStatusesRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.describe_statuses(
        grade.DescribeStatusesRequest()
            .with_namespace_name('namespace-0001')
            .with_grade_name('grade-0001')
            .with_access_token('accessToken-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.describe_statuses({
    namespaceName="namespace-0001",
    gradeName="grade-0001",
    accessToken="accessToken-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;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.describe_statuses_async({
    namespaceName="namespace-0001",
    gradeName="grade-0001",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

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

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

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

```




---

### describeStatusesByUserId

ユーザーIDを指定してステータスの一覧を取得<br>

指定されたユーザーのグレードステータスのページネーション付きリストを取得します（サーバーサイド操作）。<br>
各ステータスは特定のグレードモデルとプロパティIDに関連付けられたグレード値を表します。<br>
オプションでグレードモデル名フィルタを指定して、特定のグレードモデルのステータスのみを取得できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gradeName | string |  | |  |  ~ 128文字 | グレードモデル名 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| pageToken | string |  | |  |  ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int |  | | 30 | 1 ~ 1000 | データの取得件数 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;Status&gt;](#status) | ステータスのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.DescribeStatusesByUserId(
    &grade.DescribeStatusesByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        GradeName: pointy.String("grade-0001"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DescribeStatusesByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->describeStatusesByUserId(
        (new DescribeStatusesByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withGradeName("grade-0001")
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.DescribeStatusesByUserIdRequest;
import io.gs2.grade.result.DescribeStatusesByUserIdResult;

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

try {
    DescribeStatusesByUserIdResult result = client.describeStatusesByUserId(
        new DescribeStatusesByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<Status> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.DescribeStatusesByUserIdResult> asyncResult = null;
yield return client.DescribeStatusesByUserId(
    new Gs2.Gs2Grade.Request.DescribeStatusesByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithGradeName("grade-0001")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.describeStatusesByUserId(
        new Gs2Grade.DescribeStatusesByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.describe_statuses_by_user_id(
        grade.DescribeStatusesByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_grade_name('grade-0001')
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.describe_statuses_by_user_id({
    namespaceName="namespace-0001",
    gradeName="grade-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

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

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

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.describe_statuses_by_user_id_async({
    namespaceName="namespace-0001",
    gradeName="grade-0001",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

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

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

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

```




---

### getStatus

ステータスを取得<br>

グレードモデル名とプロパティIDで識別される、リクエストしたユーザーのグレードステータスを取得します。<br>
指定されたプロパティの現在のグレード値を返します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.GetStatus(
    &grade.GetStatusRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetStatusRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getStatus(
        (new GetStatusRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetStatusRequest;
import io.gs2.grade.result.GetStatusResult;

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

try {
    GetStatusResult result = client.getStatus(
        new GetStatusRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetStatusResult> asyncResult = null;
yield return client.GetStatus(
    new Gs2.Gs2Grade.Request.GetStatusRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.getStatus(
        new Gs2Grade.GetStatusRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.get_status(
        grade.GetStatusRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.get_status({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.get_status_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    propertyId="property-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;

```




---

### getStatusByUserId

ユーザーIDを指定してステータスを取得<br>

グレードモデル名とプロパティIDで識別される、指定されたユーザーのグレードステータスを取得します（サーバーサイド操作）。<br>
指定されたプロパティの現在のグレード値を返します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.GetStatusByUserId(
    &grade.GetStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetStatusByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getStatusByUserId(
        (new GetStatusByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetStatusByUserIdRequest;
import io.gs2.grade.result.GetStatusByUserIdResult;

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

try {
    GetStatusByUserIdResult result = client.getStatusByUserId(
        new GetStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetStatusByUserIdResult> asyncResult = null;
yield return client.GetStatusByUserId(
    new Gs2.Gs2Grade.Request.GetStatusByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.getStatusByUserId(
        new Gs2Grade.GetStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.get_status_by_user_id(
        grade.GetStatusByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.get_status_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.get_status_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

```




---

### addGradeByUserId

ユーザーIDを指定してグレードを加算<br>

指定されたグレードモデルとプロパティに対して、ユーザーの現在のグレードに指定値を加算します。<br>
グレード値の更新後、リンクされた GS2-Experience ステータスにランクキャップが自動的に適用されます。<br>
ランクキャップ値は新しいグレードレベルに一致するグレードエントリから決定され。<br>
更新されたグレードステータスとともに、Experience ネームスペース名と更新された Experience ステータスを返します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| gradeValue | long |  | | 0 | 0 ~ 9223372036854775805 | 獲得グレード |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 加算後のステータス |
| experienceNamespaceName | string | GS2-Experience ネームスペース名 |
| experienceStatus | [Status](../../experience/sdk/#status) | ランクキャップ更新後の GS2-Experience ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.AddGradeByUserId(
    &grade.AddGradeByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        GradeValue: pointy.Int64(10),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
experienceNamespaceName := result.ExperienceNamespaceName
experienceStatus := result.ExperienceStatus

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\AddGradeByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->addGradeByUserId(
        (new AddGradeByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withGradeValue(10)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $experienceNamespaceName = $result->getExperienceNamespaceName();
    $experienceStatus = $result->getExperienceStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.AddGradeByUserIdRequest;
import io.gs2.grade.result.AddGradeByUserIdResult;

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

try {
    AddGradeByUserIdResult result = client.addGradeByUserId(
        new AddGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(10L)
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
    String experienceNamespaceName = result.getExperienceNamespaceName();
    Status experienceStatus = result.getExperienceStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.AddGradeByUserIdResult> asyncResult = null;
yield return client.AddGradeByUserId(
    new Gs2.Gs2Grade.Request.AddGradeByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithGradeValue(10L)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var experienceNamespaceName = result.ExperienceNamespaceName;
var experienceStatus = result.ExperienceStatus;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.addGradeByUserId(
        new Gs2Grade.AddGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(10)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const experienceNamespaceName = result.getExperienceNamespaceName();
    const experienceStatus = result.getExperienceStatus();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.add_grade_by_user_id(
        grade.AddGradeByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_grade_value(10)
            .with_time_offset_token(None)
    )
    item = result.item
    experience_namespace_name = result.experience_namespace_name
    experience_status = result.experience_status
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.add_grade_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=10,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.add_grade_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=10,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```




---

### subGrade

グレードを減算<br>

指定されたグレードモデルとプロパティに対して、リクエストしたユーザーの現在のグレードから指定値を減算します。<br>
グレード値の更新後、リンクされた GS2-Experience ステータスにランクキャップが自動的に適用されます。<br>
ランクキャップ値は新しいグレードレベルに一致するグレードエントリから決定され。<br>
更新されたグレードステータスとともに、Experience ネームスペース名と更新された Experience ステータスを返します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| gradeValue | long |  | | 0 | 0 ~ 9223372036854775805 | 失うグレード |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 減算後のステータス |
| experienceNamespaceName | string | GS2-Experience ネームスペース名 |
| experienceStatus | [Status](../../experience/sdk/#status) | ランクキャップ更新後の GS2-Experience ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.SubGrade(
    &grade.SubGradeRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        GradeValue: pointy.Int64(10),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
experienceNamespaceName := result.ExperienceNamespaceName
experienceStatus := result.ExperienceStatus

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\SubGradeRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->subGrade(
        (new SubGradeRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withGradeValue(10)
    );
    $item = $result->getItem();
    $experienceNamespaceName = $result->getExperienceNamespaceName();
    $experienceStatus = $result->getExperienceStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.SubGradeRequest;
import io.gs2.grade.result.SubGradeResult;

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

try {
    SubGradeResult result = client.subGrade(
        new SubGradeRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(10L)
    );
    Status item = result.getItem();
    String experienceNamespaceName = result.getExperienceNamespaceName();
    Status experienceStatus = result.getExperienceStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.SubGradeResult> asyncResult = null;
yield return client.SubGrade(
    new Gs2.Gs2Grade.Request.SubGradeRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithGradeValue(10L),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var experienceNamespaceName = result.ExperienceNamespaceName;
var experienceStatus = result.ExperienceStatus;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.subGrade(
        new Gs2Grade.SubGradeRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(10)
    );
    const item = result.getItem();
    const experienceNamespaceName = result.getExperienceNamespaceName();
    const experienceStatus = result.getExperienceStatus();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.sub_grade(
        grade.SubGradeRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_grade_value(10)
    )
    item = result.item
    experience_namespace_name = result.experience_namespace_name
    experience_status = result.experience_status
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.sub_grade({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=10,
})

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.sub_grade_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=10,
})

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

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```




---

### subGradeByUserId

ユーザーIDを指定してグレードを減算<br>

指定されたグレードモデルとプロパティに対して、指定されたユーザーの現在のグレードから指定値を減算します（サーバーサイド操作）。<br>
グレード値の更新後、リンクされた GS2-Experience ステータスにランクキャップが自動的に適用されます。<br>
ランクキャップ値は新しいグレードレベルに一致するグレードエントリから決定され。<br>
更新されたグレードステータスとともに、Experience ネームスペース名と更新された Experience ステータスを返します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| gradeValue | long |  | | 0 | 0 ~ 9223372036854775805 | 失うグレード |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 減算後のステータス |
| experienceNamespaceName | string | GS2-Experience ネームスペース名 |
| experienceStatus | [Status](../../experience/sdk/#status) | ランクキャップ更新後の GS2-Experience ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.SubGradeByUserId(
    &grade.SubGradeByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        GradeValue: pointy.Int64(10),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
experienceNamespaceName := result.ExperienceNamespaceName
experienceStatus := result.ExperienceStatus

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\SubGradeByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->subGradeByUserId(
        (new SubGradeByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withGradeValue(10)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $experienceNamespaceName = $result->getExperienceNamespaceName();
    $experienceStatus = $result->getExperienceStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.SubGradeByUserIdRequest;
import io.gs2.grade.result.SubGradeByUserIdResult;

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

try {
    SubGradeByUserIdResult result = client.subGradeByUserId(
        new SubGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(10L)
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
    String experienceNamespaceName = result.getExperienceNamespaceName();
    Status experienceStatus = result.getExperienceStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.SubGradeByUserIdResult> asyncResult = null;
yield return client.SubGradeByUserId(
    new Gs2.Gs2Grade.Request.SubGradeByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithGradeValue(10L)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var experienceNamespaceName = result.ExperienceNamespaceName;
var experienceStatus = result.ExperienceStatus;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.subGradeByUserId(
        new Gs2Grade.SubGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(10)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const experienceNamespaceName = result.getExperienceNamespaceName();
    const experienceStatus = result.getExperienceStatus();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.sub_grade_by_user_id(
        grade.SubGradeByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_grade_value(10)
            .with_time_offset_token(None)
    )
    item = result.item
    experience_namespace_name = result.experience_namespace_name
    experience_status = result.experience_status
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.sub_grade_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=10,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.sub_grade_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=10,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```




---

### setGradeByUserId

累計獲得グレードを設定<br>

指定されたユーザーのグレードステータスのグレード値を直接設定します（サーバーサイド操作）。<br>
更新前のグレードステータスが記録され、監査目的で 'old' フィールドとして返されます。<br>
新しいグレード値の設定後、リンクされた GS2-Experience ステータスにランクキャップが自動的に適用されます。<br>
ランクキャップ値は新しいグレードレベルに一致するグレードエントリから決定され。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| gradeValue | long |  | | 1 | 1 ~ 9223372036854775805 | 現在のグレード<br>このステータスの現在のグレード値です。連動する GS2-Experience モデルのランクキャップを決定するために、グレードモデルのグレードエントリ配列のインデックスとして使用されます。この値が変更されると、関連する経験値ステータスのランクキャップが対応するグレードエントリで定義された値に自動更新されます。 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 更新後のステータス |
| old | [Status](#status) | 更新前のステータス |
| experienceNamespaceName | string | GS2-Experience ネームスペース名 |
| experienceStatus | [Status](../../experience/sdk/#status) | ランクキャップ更新後の GS2-Experience ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.SetGradeByUserId(
    &grade.SetGradeByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        GradeValue: pointy.Int64(100),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
old := result.Old
experienceNamespaceName := result.ExperienceNamespaceName
experienceStatus := result.ExperienceStatus

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\SetGradeByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->setGradeByUserId(
        (new SetGradeByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withGradeValue(100)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $old = $result->getOld();
    $experienceNamespaceName = $result->getExperienceNamespaceName();
    $experienceStatus = $result->getExperienceStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.SetGradeByUserIdRequest;
import io.gs2.grade.result.SetGradeByUserIdResult;

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

try {
    SetGradeByUserIdResult result = client.setGradeByUserId(
        new SetGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(100L)
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
    Status old = result.getOld();
    String experienceNamespaceName = result.getExperienceNamespaceName();
    Status experienceStatus = result.getExperienceStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.SetGradeByUserIdResult> asyncResult = null;
yield return client.SetGradeByUserId(
    new Gs2.Gs2Grade.Request.SetGradeByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithGradeValue(100L)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;
var experienceNamespaceName = result.ExperienceNamespaceName;
var experienceStatus = result.ExperienceStatus;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.setGradeByUserId(
        new Gs2Grade.SetGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withGradeValue(100)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const old = result.getOld();
    const experienceNamespaceName = result.getExperienceNamespaceName();
    const experienceStatus = result.getExperienceStatus();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.set_grade_by_user_id(
        grade.SetGradeByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_grade_value(100)
            .with_time_offset_token(None)
    )
    item = result.item
    old = result.old
    experience_namespace_name = result.experience_namespace_name
    experience_status = result.experience_status
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.set_grade_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=100,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
old = result.old;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.set_grade_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    gradeValue=100,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
old = result.old;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```




---

### applyRankCap

GS2-Experienceステータスにランクキャップを適用<br>

リクエストしたユーザーの現在のグレードに対応するランクキャップを、リンクされた GS2-Experience ステータスに適用します。<br>
現在のグレード値に一致するグレードエントリを参照してランクキャップ値を決定し。<br>
グレードが外部で変更され、Experience のランクキャップを同期する必要がある場合に有用です。<br>
更新されたグレードステータスとともに、Experience ネームスペース名と更新された Experience ステータスを返します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステータス |
| experienceNamespaceName | string | GS2-Experience ネームスペース名 |
| experienceStatus | [Status](../../experience/sdk/#status) | ランクキャップ更新後の GS2-Experience ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.ApplyRankCap(
    &grade.ApplyRankCapRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
experienceNamespaceName := result.ExperienceNamespaceName
experienceStatus := result.ExperienceStatus

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\ApplyRankCapRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->applyRankCap(
        (new ApplyRankCapRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
    );
    $item = $result->getItem();
    $experienceNamespaceName = $result->getExperienceNamespaceName();
    $experienceStatus = $result->getExperienceStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.ApplyRankCapRequest;
import io.gs2.grade.result.ApplyRankCapResult;

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

try {
    ApplyRankCapResult result = client.applyRankCap(
        new ApplyRankCapRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
    );
    Status item = result.getItem();
    String experienceNamespaceName = result.getExperienceNamespaceName();
    Status experienceStatus = result.getExperienceStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.ApplyRankCapResult> asyncResult = null;
yield return client.ApplyRankCap(
    new Gs2.Gs2Grade.Request.ApplyRankCapRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var experienceNamespaceName = result.ExperienceNamespaceName;
var experienceStatus = result.ExperienceStatus;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.applyRankCap(
        new Gs2Grade.ApplyRankCapRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
    );
    const item = result.getItem();
    const experienceNamespaceName = result.getExperienceNamespaceName();
    const experienceStatus = result.getExperienceStatus();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.apply_rank_cap(
        grade.ApplyRankCapRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
    )
    item = result.item
    experience_namespace_name = result.experience_namespace_name
    experience_status = result.experience_status
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.apply_rank_cap({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
})

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.apply_rank_cap_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    propertyId="property-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;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```




---

### applyRankCapByUserId

ユーザーIDを指定して GS2-Experienceステータスにランクキャップを適用<br>

指定されたユーザーの現在のグレードに対応するランクキャップを、リンクされた GS2-Experience ステータスに適用します（サーバーサイド操作）。<br>
現在のグレード値に一致するグレードエントリを参照してランクキャップ値を決定し。<br>
グレードが外部で変更され、Experience のランクキャップを同期する必要がある場合に有用です。<br>
更新されたグレードステータスとともに、Experience ネームスペース名と更新された Experience ステータスを返します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステータス |
| experienceNamespaceName | string | GS2-Experience ネームスペース名 |
| experienceStatus | [Status](../../experience/sdk/#status) | ランクキャップ更新後の GS2-Experience ステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.ApplyRankCapByUserId(
    &grade.ApplyRankCapByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
experienceNamespaceName := result.ExperienceNamespaceName
experienceStatus := result.ExperienceStatus

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\ApplyRankCapByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->applyRankCapByUserId(
        (new ApplyRankCapByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $experienceNamespaceName = $result->getExperienceNamespaceName();
    $experienceStatus = $result->getExperienceStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.ApplyRankCapByUserIdRequest;
import io.gs2.grade.result.ApplyRankCapByUserIdResult;

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

try {
    ApplyRankCapByUserIdResult result = client.applyRankCapByUserId(
        new ApplyRankCapByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
    String experienceNamespaceName = result.getExperienceNamespaceName();
    Status experienceStatus = result.getExperienceStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.ApplyRankCapByUserIdResult> asyncResult = null;
yield return client.ApplyRankCapByUserId(
    new Gs2.Gs2Grade.Request.ApplyRankCapByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var experienceNamespaceName = result.ExperienceNamespaceName;
var experienceStatus = result.ExperienceStatus;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.applyRankCapByUserId(
        new Gs2Grade.ApplyRankCapByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const experienceNamespaceName = result.getExperienceNamespaceName();
    const experienceStatus = result.getExperienceStatus();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.apply_rank_cap_by_user_id(
        grade.ApplyRankCapByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    experience_namespace_name = result.experience_namespace_name
    experience_status = result.experience_status
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.apply_rank_cap_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.apply_rank_cap_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;
experienceNamespaceName = result.experienceNamespaceName;
experienceStatus = result.experienceStatus;

```




---

### deleteStatusByUserId

ユーザーIDを指定してステータスを削除<br>

グレードモデル名とプロパティIDで識別される、指定されたユーザーのグレードステータスを削除します（サーバーサイド操作）。<br>
削除されたステータスデータがレスポンスで返されます。<br>
リンクされた GS2-Experience のランクキャップは自動的には更新されないことに注意してください。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 削除したステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.DeleteStatusByUserId(
    &grade.DeleteStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DeleteStatusByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->deleteStatusByUserId(
        (new DeleteStatusByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.DeleteStatusByUserIdRequest;
import io.gs2.grade.result.DeleteStatusByUserIdResult;

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

try {
    DeleteStatusByUserIdResult result = client.deleteStatusByUserId(
        new DeleteStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.DeleteStatusByUserIdResult> asyncResult = null;
yield return client.DeleteStatusByUserId(
    new Gs2.Gs2Grade.Request.DeleteStatusByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.deleteStatusByUserId(
        new Gs2Grade.DeleteStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.delete_status_by_user_id(
        grade.DeleteStatusByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.delete_status_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.delete_status_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

```




---

### verifyGrade

グレードを検証<br>

リクエストしたユーザーのグレード値が指定された条件を満たすことを検証します。<br>
6つの比較演算子をサポートします：less（未満）、lessEqual（以下）、greater（超過）、greaterEqual（以上）、equal（一致）、notEqual（不一致）。<br>
条件が満たされない場合、期待値と実際の値を含む説明的なエラーメッセージが返されます。<br>
multiplyValueSpecifyingQuantity が true の場合、検証の閾値は指定された数量で乗算されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| verifyType | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"less",<br>&nbsp;&nbsp;"lessEqual",<br>&nbsp;&nbsp;"greater",<br>&nbsp;&nbsp;"greaterEqual",<br>&nbsp;&nbsp;"equal",<br>&nbsp;&nbsp;"notEqual"<br>}<br> |  | ✓|  |  | 検証の種類"less": グレードが指定値未満であること / "lessEqual": グレードが指定値以下であること / "greater": グレードが指定値超過であること / "greaterEqual": グレードが指定値以上であること / "equal": グレードが指定値と一致すること / "notEqual": グレードが指定値と一致しないこと /  |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| gradeValue | long |  | | 1 | 1 ~ 9223372036854775805 | 現在のグレード<br>このステータスの現在のグレード値です。連動する GS2-Experience モデルのランクキャップを決定するために、グレードモデルのグレードエントリ配列のインデックスとして使用されます。この値が変更されると、関連する経験値ステータスのランクキャップが対応するグレードエントリで定義された値に自動更新されます。 |
| multiplyValueSpecifyingQuantity | bool |  | | false |  | 数量指定した際に、検証に使用する値も乗算するか |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 削除したステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.VerifyGrade(
    &grade.VerifyGradeRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        GradeName: pointy.String("grade-0001"),
        VerifyType: pointy.String("less"),
        PropertyId: pointy.String("property-0001"),
        GradeValue: pointy.Int64(2),
        MultiplyValueSpecifyingQuantity: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\VerifyGradeRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->verifyGrade(
        (new VerifyGradeRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withGradeName("grade-0001")
            ->withVerifyType("less")
            ->withPropertyId("property-0001")
            ->withGradeValue(2)
            ->withMultiplyValueSpecifyingQuantity(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.VerifyGradeRequest;
import io.gs2.grade.result.VerifyGradeResult;

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

try {
    VerifyGradeResult result = client.verifyGrade(
        new VerifyGradeRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withVerifyType("less")
            .withPropertyId("property-0001")
            .withGradeValue(2L)
            .withMultiplyValueSpecifyingQuantity(null)
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.VerifyGradeResult> asyncResult = null;
yield return client.VerifyGrade(
    new Gs2.Gs2Grade.Request.VerifyGradeRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithGradeName("grade-0001")
        .WithVerifyType("less")
        .WithPropertyId("property-0001")
        .WithGradeValue(2L)
        .WithMultiplyValueSpecifyingQuantity(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.verifyGrade(
        new Gs2Grade.VerifyGradeRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withVerifyType("less")
            .withPropertyId("property-0001")
            .withGradeValue(2)
            .withMultiplyValueSpecifyingQuantity(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.verify_grade(
        grade.VerifyGradeRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_grade_name('grade-0001')
            .with_verify_type('less')
            .with_property_id('property-0001')
            .with_grade_value(2)
            .with_multiply_value_specifying_quantity(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.verify_grade({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    verifyType="less",
    propertyId="property-0001",
    gradeValue=2,
    multiplyValueSpecifyingQuantity=nil,
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.verify_grade_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    verifyType="less",
    propertyId="property-0001",
    gradeValue=2,
    multiplyValueSpecifyingQuantity=nil,
})

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

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

result = api_result.result
item = result.item;

```




---

### verifyGradeByUserId

ユーザーIDを指定してグレードを検証<br>

指定されたユーザーのグレード値が指定された条件を満たすことを検証します（サーバーサイド操作）。<br>
6つの比較演算子をサポートします：less（未満）、lessEqual（以下）、greater（超過）、greaterEqual（以上）、equal（一致）、notEqual（不一致）。<br>
条件が満たされない場合、期待値と実際の値を含む説明的なエラーメッセージが返されます。<br>
multiplyValueSpecifyingQuantity が true の場合、検証の閾値は指定された数量で乗算されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| verifyType | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"less",<br>&nbsp;&nbsp;"lessEqual",<br>&nbsp;&nbsp;"greater",<br>&nbsp;&nbsp;"greaterEqual",<br>&nbsp;&nbsp;"equal",<br>&nbsp;&nbsp;"notEqual"<br>}<br> |  | ✓|  |  | 検証の種類"less": グレードが指定値未満であること / "lessEqual": グレードが指定値以下であること / "greater": グレードが指定値超過であること / "greaterEqual": グレードが指定値以上であること / "equal": グレードが指定値と一致すること / "notEqual": グレードが指定値と一致しないこと /  |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| gradeValue | long |  | | 1 | 1 ~ 9223372036854775805 | 現在のグレード<br>このステータスの現在のグレード値です。連動する GS2-Experience モデルのランクキャップを決定するために、グレードモデルのグレードエントリ配列のインデックスとして使用されます。この値が変更されると、関連する経験値ステータスのランクキャップが対応するグレードエントリで定義された値に自動更新されます。 |
| multiplyValueSpecifyingQuantity | bool |  | | false |  | 数量指定した際に、検証に使用する値も乗算するか |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 削除したステータス |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.VerifyGradeByUserId(
    &grade.VerifyGradeByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        VerifyType: pointy.String("less"),
        PropertyId: pointy.String("property-0001"),
        GradeValue: pointy.Int64(2),
        MultiplyValueSpecifyingQuantity: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\VerifyGradeByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->verifyGradeByUserId(
        (new VerifyGradeByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withVerifyType("less")
            ->withPropertyId("property-0001")
            ->withGradeValue(2)
            ->withMultiplyValueSpecifyingQuantity(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.VerifyGradeByUserIdRequest;
import io.gs2.grade.result.VerifyGradeByUserIdResult;

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

try {
    VerifyGradeByUserIdResult result = client.verifyGradeByUserId(
        new VerifyGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withVerifyType("less")
            .withPropertyId("property-0001")
            .withGradeValue(2L)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
    Status item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.VerifyGradeByUserIdResult> asyncResult = null;
yield return client.VerifyGradeByUserId(
    new Gs2.Gs2Grade.Request.VerifyGradeByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithVerifyType("less")
        .WithPropertyId("property-0001")
        .WithGradeValue(2L)
        .WithMultiplyValueSpecifyingQuantity(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.verifyGradeByUserId(
        new Gs2Grade.VerifyGradeByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withVerifyType("less")
            .withPropertyId("property-0001")
            .withGradeValue(2)
            .withMultiplyValueSpecifyingQuantity(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.verify_grade_by_user_id(
        grade.VerifyGradeByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_verify_type('less')
            .with_property_id('property-0001')
            .with_grade_value(2)
            .with_multiply_value_specifying_quantity(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.verify_grade_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    verifyType="less",
    propertyId="property-0001",
    gradeValue=2,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.verify_grade_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    verifyType="less",
    propertyId="property-0001",
    gradeValue=2,
    multiplyValueSpecifyingQuantity=nil,
    timeOffsetToken=nil,
})

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

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

result = api_result.result
item = result.item;

```




---

### verifyGradeUpMaterial

グレードアップに使用する素材を検証<br>

素材のプロパティIDが指定されたプロパティのグレードアップに有効かどうかを検証します。<br>
検証はグレードエントリの PropertyIdRegex と GradeUpPropertyIdRegex から正規表現パターンを構築し、素材のプロパティIDがマッチするかを確認します。<br>
2つの検証タイプをサポートします：'match'（素材がパターンにマッチすること）と 'notMatch'（素材がパターンにマッチしないこと）。<br>
グレードアップのために消費する素材アイテムが適格であることを検証するために使用されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| verifyType | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"match",<br>&nbsp;&nbsp;"notMatch"<br>}<br> |  | ✓|  |  | 検証の種類"match": 条件に一致していること / "notMatch": 条件に一致していないこと /  |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| materialPropertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.VerifyGradeUpMaterial(
    &grade.VerifyGradeUpMaterialRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        GradeName: pointy.String("grade-0001"),
        VerifyType: pointy.String("match"),
        PropertyId: pointy.String("property-0001"),
        MaterialPropertyId: pointy.String("property-0002"),
    }
)
if err != nil {
    panic("error occurred")
}

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\VerifyGradeUpMaterialRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->verifyGradeUpMaterial(
        (new VerifyGradeUpMaterialRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withGradeName("grade-0001")
            ->withVerifyType("match")
            ->withPropertyId("property-0001")
            ->withMaterialPropertyId("property-0002")
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.VerifyGradeUpMaterialRequest;
import io.gs2.grade.result.VerifyGradeUpMaterialResult;

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

try {
    VerifyGradeUpMaterialResult result = client.verifyGradeUpMaterial(
        new VerifyGradeUpMaterialRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withVerifyType("match")
            .withPropertyId("property-0001")
            .withMaterialPropertyId("property-0002")
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.VerifyGradeUpMaterialResult> asyncResult = null;
yield return client.VerifyGradeUpMaterial(
    new Gs2.Gs2Grade.Request.VerifyGradeUpMaterialRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithGradeName("grade-0001")
        .WithVerifyType("match")
        .WithPropertyId("property-0001")
        .WithMaterialPropertyId("property-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.verifyGradeUpMaterial(
        new Gs2Grade.VerifyGradeUpMaterialRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withGradeName("grade-0001")
            .withVerifyType("match")
            .withPropertyId("property-0001")
            .withMaterialPropertyId("property-0002")
    );
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.verify_grade_up_material(
        grade.VerifyGradeUpMaterialRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_grade_name('grade-0001')
            .with_verify_type('match')
            .with_property_id('property-0001')
            .with_material_property_id('property-0002')
    )
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.verify_grade_up_material({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    verifyType="match",
    propertyId="property-0001",
    materialPropertyId="property-0002",
})

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

result = api_result.result

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.verify_grade_up_material_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    gradeName="grade-0001",
    verifyType="match",
    propertyId="property-0001",
    materialPropertyId="property-0002",
})

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

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

result = api_result.result

```




---

### verifyGradeUpMaterialByUserId

ユーザーIDを指定してグレードアップに使用する素材を検証<br>

指定されたユーザーの指定されたプロパティのグレードアップに素材のプロパティIDが有効かどうかを検証します（サーバーサイド操作）。<br>
検証はグレードエントリの PropertyIdRegex と GradeUpPropertyIdRegex から正規表現パターンを構築し、素材のプロパティIDがマッチするかを確認します。<br>
2つの検証タイプをサポートします：'match'（素材がパターンにマッチすること）と 'notMatch'（素材がパターンにマッチしないこと）。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| verifyType | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"match",<br>&nbsp;&nbsp;"notMatch"<br>}<br> |  | ✓|  |  | 検証の種類"match": 条件に一致していること / "notMatch": 条件に一致していないこと /  |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| materialPropertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.VerifyGradeUpMaterialByUserId(
    &grade.VerifyGradeUpMaterialByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        VerifyType: pointy.String("match"),
        PropertyId: pointy.String("property-0001"),
        MaterialPropertyId: pointy.String("property-0002"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\VerifyGradeUpMaterialByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->verifyGradeUpMaterialByUserId(
        (new VerifyGradeUpMaterialByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withVerifyType("match")
            ->withPropertyId("property-0001")
            ->withMaterialPropertyId("property-0002")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.VerifyGradeUpMaterialByUserIdRequest;
import io.gs2.grade.result.VerifyGradeUpMaterialByUserIdResult;

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

try {
    VerifyGradeUpMaterialByUserIdResult result = client.verifyGradeUpMaterialByUserId(
        new VerifyGradeUpMaterialByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withVerifyType("match")
            .withPropertyId("property-0001")
            .withMaterialPropertyId("property-0002")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.VerifyGradeUpMaterialByUserIdResult> asyncResult = null;
yield return client.VerifyGradeUpMaterialByUserId(
    new Gs2.Gs2Grade.Request.VerifyGradeUpMaterialByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithVerifyType("match")
        .WithPropertyId("property-0001")
        .WithMaterialPropertyId("property-0002")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.verifyGradeUpMaterialByUserId(
        new Gs2Grade.VerifyGradeUpMaterialByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withVerifyType("match")
            .withPropertyId("property-0001")
            .withMaterialPropertyId("property-0002")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.verify_grade_up_material_by_user_id(
        grade.VerifyGradeUpMaterialByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_verify_type('match')
            .with_property_id('property-0001')
            .with_material_property_id('property-0002')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.verify_grade_up_material_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    verifyType="match",
    propertyId="property-0001",
    materialPropertyId="property-0002",
    timeOffsetToken=nil,
})

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

result = api_result.result

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.verify_grade_up_material_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    verifyType="match",
    propertyId="property-0001",
    materialPropertyId="property-0002",
    timeOffsetToken=nil,
})

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

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

result = api_result.result

```




---

### multiplyAcquireActionsByUserId

グレードに基づくレートで入手アクションを乗算<br>

指定された入手アクションの数量を、ユーザーの現在のグレードに基づくレート乗数で乗算します。<br>
レート乗数は指定された rateName と現在のグレード値を使用して、グレードモデルの acquireActionRates から参照されます。<br>
乗算された入手アクションはトランザクションとして実行され、グレードに基づく報酬スケーリング（例：高グレードほど多くのリソースを獲得）を実現します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>このステータスが属するグレードモデルの名前です。グレードエントリのマッピング、連動する経験値モデル、報酬加算テーブルを含むグレードモデル定義を参照します。 |
| propertyId | string |  | ✓|  |  ~ 1024文字 | プロパティID<br>このグレードステータスの開発者定義の識別子で、ユーザーとグレードモデル内で一意です。連動する GS2-Experience ステータスのプロパティIDと同じ値を使用することを強く推奨します。これにより、グレード値とランクキャップの正しい同期が保証されます。 |
| rateName | string |  | ✓|  |  ~ 128文字 | 報酬加算テーブル名<br>グレードモデル内でこの倍率テーブルを一意に識別する名前です。トランザクションの特定の入手アクションにグレードベースの報酬スケーリングを適用する際に参照されます。 |
| acquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  | | [] | 0 ~ 100 items | 入手アクションリスト |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;AcquireAction&gt;](#acquireaction) | 報酬 |
| transactionId | string | 発行されたトランザクションID |
| stampSheet | string | スタンプシート |
| stampSheetEncryptionKeyId | string | スタンプシートの署名計算に使用した暗号鍵GRN |
| autoRunStampSheet | bool? | トランザクションの自動実行が有効か |
| atomicCommit | bool? | トランザクションをアトミックにコミットするか |
| transaction | string | 発行されたトランザクション |
| transactionResult | [TransactionResult](#transactionresult) | トランザクション実行結果 |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.MultiplyAcquireActionsByUserId(
    &grade.MultiplyAcquireActionsByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        GradeName: pointy.String("grade-0001"),
        PropertyId: pointy.String("property-0001"),
        RateName: pointy.String("rate-0001"),
        AcquireActions: []grade.AcquireAction{
            grade.AcquireAction{
                Action: pointy.String("Gs2Grade:AddRankCapByUserId"),
                Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"gradeName\": \"character\", \"propertyId\": \"property-0001\", \"userId\": \"#{userId}\", \"rankCapValue\": 1}"),
            },
        },
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet
atomicCommit := result.AtomicCommit
transaction := result.Transaction
transactionResult := result.TransactionResult

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\MultiplyAcquireActionsByUserIdRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->multiplyAcquireActionsByUserId(
        (new MultiplyAcquireActionsByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withGradeName("grade-0001")
            ->withPropertyId("property-0001")
            ->withRateName("rate-0001")
            ->withAcquireActions([
                (new AcquireAction())
                    ->withAction("Gs2Grade:AddRankCapByUserId")
                    ->withRequest("{\"namespaceName\": \"namespace-0001\", \"gradeName\": \"character\", \"propertyId\": \"property-0001\", \"userId\": \"#{userId}\", \"rankCapValue\": 1}"),
            ])
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $transactionId = $result->getTransactionId();
    $stampSheet = $result->getStampSheet();
    $stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
    $autoRunStampSheet = $result->getAutoRunStampSheet();
    $atomicCommit = $result->getAtomicCommit();
    $transaction = $result->getTransaction();
    $transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.MultiplyAcquireActionsByUserIdRequest;
import io.gs2.grade.result.MultiplyAcquireActionsByUserIdResult;

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

try {
    MultiplyAcquireActionsByUserIdResult result = client.multiplyAcquireActionsByUserId(
        new MultiplyAcquireActionsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withRateName("rate-0001")
            .withAcquireActions(Arrays.asList(
                new AcquireAction()
                    .withAction("Gs2Grade:AddRankCapByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"gradeName\": \"character\", \"propertyId\": \"property-0001\", \"userId\": \"#{userId}\", \"rankCapValue\": 1}")
            ))
            .withTimeOffsetToken(null)
    );
    List<AcquireAction> items = result.getItems();
    String transactionId = result.getTransactionId();
    String stampSheet = result.getStampSheet();
    String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    boolean autoRunStampSheet = result.getAutoRunStampSheet();
    boolean atomicCommit = result.getAtomicCommit();
    String transaction = result.getTransaction();
    TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.MultiplyAcquireActionsByUserIdResult> asyncResult = null;
yield return client.MultiplyAcquireActionsByUserId(
    new Gs2.Gs2Grade.Request.MultiplyAcquireActionsByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithGradeName("grade-0001")
        .WithPropertyId("property-0001")
        .WithRateName("rate-0001")
        .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
            new Gs2.Core.Model.AcquireAction()
                .WithAction("Gs2Grade:AddRankCapByUserId")
                .WithRequest("{\"namespaceName\": \"namespace-0001\", \"gradeName\": \"character\", \"propertyId\": \"property-0001\", \"userId\": \"#{userId}\", \"rankCapValue\": 1}"),
        })
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.multiplyAcquireActionsByUserId(
        new Gs2Grade.MultiplyAcquireActionsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withGradeName("grade-0001")
            .withPropertyId("property-0001")
            .withRateName("rate-0001")
            .withAcquireActions([
                new Gs2Grade.model.AcquireAction()
                    .withAction("Gs2Grade:AddRankCapByUserId")
                    .withRequest("{\"namespaceName\": \"namespace-0001\", \"gradeName\": \"character\", \"propertyId\": \"property-0001\", \"userId\": \"#{userId}\", \"rankCapValue\": 1}"),
            ])
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const transactionId = result.getTransactionId();
    const stampSheet = result.getStampSheet();
    const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
    const autoRunStampSheet = result.getAutoRunStampSheet();
    const atomicCommit = result.getAtomicCommit();
    const transaction = result.getTransaction();
    const transactionResult = result.getTransactionResult();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.multiply_acquire_actions_by_user_id(
        grade.MultiplyAcquireActionsByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_grade_name('grade-0001')
            .with_property_id('property-0001')
            .with_rate_name('rate-0001')
            .with_acquire_actions([
                grade.AcquireAction()
                    .with_action('Gs2Grade:AddRankCapByUserId')
                    .with_request('{"namespaceName": "namespace-0001", "gradeName": "character", "propertyId": "property-0001", "userId": "#{userId}", "rankCapValue": 1}'),
            ])
            .with_time_offset_token(None)
    )
    items = result.items
    transaction_id = result.transaction_id
    stamp_sheet = result.stamp_sheet
    stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
    auto_run_stamp_sheet = result.auto_run_stamp_sheet
    atomic_commit = result.atomic_commit
    transaction = result.transaction
    transaction_result = result.transaction_result
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.multiply_acquire_actions_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    rateName="rate-0001",
    acquireActions={
        {
            action="Gs2Grade:AddRankCapByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"gradeName\": \"character\", \"propertyId\": \"property-0001\", \"userId\": \"#{userId}\", \"rankCapValue\": 1}",
        }
    },
    timeOffsetToken=nil,
})

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

result = api_result.result
items = result.items;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.multiply_acquire_actions_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    gradeName="grade-0001",
    propertyId="property-0001",
    rateName="rate-0001",
    acquireActions={
        {
            action="Gs2Grade:AddRankCapByUserId",
            request="{\"namespaceName\": \"namespace-0001\", \"gradeName\": \"character\", \"propertyId\": \"property-0001\", \"userId\": \"#{userId}\", \"rankCapValue\": 1}",
        }
    },
    timeOffsetToken=nil,
})

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

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

result = api_result.result
items = result.items;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```




---

### describeGradeModels

グレードモデルの一覧を取得<br>

指定されたネームスペースで現在有効化（公開）されているグレードモデルの一覧を取得します。<br>
グレードモデルはグレードエントリ、デフォルトグレード、リンクされたエクスペリエンスモデル、入手アクションレート乗数を含むグレード構造を定義します。<br>
グレードモデルマスターとは異なり、読み取り専用で現在使用中の構成を表します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;GradeModel&gt;](#grademodel) | グレードモデルリスト |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.DescribeGradeModels(
    &grade.DescribeGradeModelsRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DescribeGradeModelsRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->describeGradeModels(
        (new DescribeGradeModelsRequest())
            ->withNamespaceName("namespace-0001")
    );
    $items = $result->getItems();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.DescribeGradeModelsRequest;
import io.gs2.grade.result.DescribeGradeModelsResult;

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

try {
    DescribeGradeModelsResult result = client.describeGradeModels(
        new DescribeGradeModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<GradeModel> items = result.getItems();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.DescribeGradeModelsResult> asyncResult = null;
yield return client.DescribeGradeModels(
    new Gs2.Gs2Grade.Request.DescribeGradeModelsRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.describe_grade_models(
        grade.DescribeGradeModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
items = result.items;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
items = result.items;

```




---

### getGradeModel

グレードモデルを取得<br>

名前を指定して、特定の現在有効なグレードモデルの詳細情報を取得します。<br>
リンクされたエクスペリエンスサービスの進行レベルと関連するランクキャップ値を定義するグレードエントリを含みます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名<br>グレードモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [GradeModel](#grademodel) | グレードモデル |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.GetGradeModel(
    &grade.GetGradeModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        GradeName: pointy.String("grade-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetGradeModelRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getGradeModel(
        (new GetGradeModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withGradeName("grade-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetGradeModelRequest;
import io.gs2.grade.result.GetGradeModelResult;

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

try {
    GetGradeModelResult result = client.getGradeModel(
        new GetGradeModelRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-0001")
    );
    GradeModel item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetGradeModelResult> asyncResult = null;
yield return client.GetGradeModel(
    new Gs2.Gs2Grade.Request.GetGradeModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithGradeName("grade-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.getGradeModel(
        new Gs2Grade.GetGradeModelRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.get_grade_model(
        grade.GetGradeModelRequest()
            .with_namespace_name('namespace-0001')
            .with_grade_name('grade-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.get_grade_model({
    namespaceName="namespace-0001",
    gradeName="grade-0001",
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.get_grade_model_async({
    namespaceName="namespace-0001",
    gradeName="grade-0001",
})

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

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

result = api_result.result
item = result.item;

```




---

### exportMaster

グレードモデルマスターを有効化可能なマスターデータ形式でエクスポート<br>

ネームスペース内のすべてのグレードモデルマスター定義を、有効化に適した単一のJSONドキュメントとしてエクスポートします。<br>
エクスポートされるデータにはグレードエントリ、デフォルトグレード、エクスペリエンスモデルリンク、入手アクションレートを含むグレードモデルが含まれます。<br>
有効化前のマスターデータの確認や、現在のマスター設定のバックアップに使用します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentGradeMaster](#currentgrademaster) | 有効化可能なグレードモデルのマスターデータ |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\ExportMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->exportMaster(
        (new ExportMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.ExportMasterRequest;
import io.gs2.grade.result.ExportMasterResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.ExportMasterResult> asyncResult = null;
yield return client.ExportMaster(
    new Gs2.Gs2Grade.Request.ExportMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
item = result.item;

```




---

### getCurrentGradeMaster

現在アクティブなグレードモデルのマスターデータを取得<br>

指定されたネームスペースで現在有効化され使用中のグレードモデルマスターデータを取得します。<br>
返されるデータには、現在ランタイムリクエストを処理しているすべてのグレードモデルのJSON定義が含まれます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentGradeMaster](#currentgrademaster) | 現在アクティブなグレードモデルのマスターデータ |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.GetCurrentGradeMaster(
    &grade.GetCurrentGradeMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetCurrentGradeMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getCurrentGradeMaster(
        (new GetCurrentGradeMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetCurrentGradeMasterRequest;
import io.gs2.grade.result.GetCurrentGradeMasterResult;

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

try {
    GetCurrentGradeMasterResult result = client.getCurrentGradeMaster(
        new GetCurrentGradeMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentGradeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetCurrentGradeMasterResult> asyncResult = null;
yield return client.GetCurrentGradeMaster(
    new Gs2.Gs2Grade.Request.GetCurrentGradeMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.get_current_grade_master(
        grade.GetCurrentGradeMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
item = result.item;

```




---

### preUpdateCurrentGradeMaster

現在アクティブなグレードモデルのマスターデータを更新（3フェーズ版）<br>

1MBを超えるマスターデータをアップロードする場合は、3フェーズで更新を行います。<br>
1. このAPIを実行し、アップロード用のトークンとURLを取得します。<br>
2. 取得したURLに対して、マスターデータをアップロードします。<br>
3. UpdateCurrentGradeMaster にアップロードで取得したトークンを渡して実行し、マスターデータを反映します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| uploadToken | string | アップロード後に結果を反映する際に使用するトークン |
| uploadUrl | string | アップロード処理の実行に使用するURL |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.PreUpdateCurrentGradeMaster(
    &grade.PreUpdateCurrentGradeMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\PreUpdateCurrentGradeMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentGradeMaster(
        (new PreUpdateCurrentGradeMasterRequest())
            ->withNamespaceName("namespace-0001")
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.PreUpdateCurrentGradeMasterRequest;
import io.gs2.grade.result.PreUpdateCurrentGradeMasterResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.PreUpdateCurrentGradeMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentGradeMaster(
    new Gs2.Gs2Grade.Request.PreUpdateCurrentGradeMasterRequest()
        .WithNamespaceName("namespace-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.pre_update_current_grade_master(
        grade.PreUpdateCurrentGradeMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

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

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

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

```




---

### updateCurrentGradeMaster

現在アクティブなグレードモデルのマスターデータを更新<br>

新しいグレードモデルマスターデータを有効化し、現在アクティブな設定を置き換えます。<br>
2つのモードをサポートします：'direct' はインラインのマスターデータ（1MB未満のデータに適合）、'preUpload' は PreUpdate で事前にアップロードしたデータを適用します。<br>
有効化後、すべてのグレード関連のランタイム操作（グレード参照、ランクキャップ適用、入手アクションレート乗算）は新しい設定を使用します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| mode | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"direct",<br>&nbsp;&nbsp;"preUpload"<br>}<br> |  | | "direct" |  | 更新モード"direct": マスターデータを直接更新 / "preUpload": マスターデータをアップロードしてから更新 /  |
| settings | string | {mode} == "direct" | ✓※|  |  ~ 5242880 バイト (5MB) | マスターデータ<br>※ mode が "direct" であれば必須 |
| uploadToken | string | {mode} == "preUpload" | ✓※|  |  ~ 1024文字 | 事前アップロードで取得したトークン<br>アップロードしたマスターデータを適用するために使用されます。<br>※ mode が "preUpload" であれば必須 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentGradeMaster](#currentgrademaster) | 更新された現在アクティブなグレードモデルのマスターデータ |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentGradeMaster(
    &grade.UpdateCurrentGradeMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Mode: pointy.String("direct"),
        Settings: pointy.String("{\"version\": \"2023-12-25\", \"gradeModels\": [{\"name\": \"grade-0001\", \"metadata\": \"GRADE_0001\", \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001\", \"defaultGrades\": [{\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*\", \"defaultGradeValue\": 2}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*\", \"defaultGradeValue\": 3}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*\", \"defaultGradeValue\": 4}], \"gradeEntries\": [{\"rankCapValue\": 50, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 60, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 70, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 80, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}]}]}"),
        UploadToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\UpdateCurrentGradeMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->updateCurrentGradeMaster(
        (new UpdateCurrentGradeMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings('{"version": "2023-12-25", "gradeModels": [{"name": "grade-0001", "metadata": "GRADE_0001", "experienceModelId": "grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001", "defaultGrades": [{"propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*", "defaultGradeValue": 2}, {"propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*", "defaultGradeValue": 3}, {"propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*", "defaultGradeValue": 4}], "gradeEntries": [{"rankCapValue": 50, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}, {"rankCapValue": 60, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}, {"rankCapValue": 70, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}, {"rankCapValue": 80, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}]}]}')
            ->withUploadToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.UpdateCurrentGradeMasterRequest;
import io.gs2.grade.result.UpdateCurrentGradeMasterResult;

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

try {
    UpdateCurrentGradeMasterResult result = client.updateCurrentGradeMaster(
        new UpdateCurrentGradeMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-12-25\", \"gradeModels\": [{\"name\": \"grade-0001\", \"metadata\": \"GRADE_0001\", \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001\", \"defaultGrades\": [{\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*\", \"defaultGradeValue\": 2}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*\", \"defaultGradeValue\": 3}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*\", \"defaultGradeValue\": 4}], \"gradeEntries\": [{\"rankCapValue\": 50, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 60, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 70, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 80, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}]}]}")
            .withUploadToken(null)
    );
    CurrentGradeMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.UpdateCurrentGradeMasterResult> asyncResult = null;
yield return client.UpdateCurrentGradeMaster(
    new Gs2.Gs2Grade.Request.UpdateCurrentGradeMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\"version\": \"2023-12-25\", \"gradeModels\": [{\"name\": \"grade-0001\", \"metadata\": \"GRADE_0001\", \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001\", \"defaultGrades\": [{\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*\", \"defaultGradeValue\": 2}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*\", \"defaultGradeValue\": 3}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*\", \"defaultGradeValue\": 4}], \"gradeEntries\": [{\"rankCapValue\": 50, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 60, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 70, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 80, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}]}]}")
        .WithUploadToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.updateCurrentGradeMaster(
        new Gs2Grade.UpdateCurrentGradeMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-12-25\", \"gradeModels\": [{\"name\": \"grade-0001\", \"metadata\": \"GRADE_0001\", \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001\", \"defaultGrades\": [{\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*\", \"defaultGradeValue\": 2}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*\", \"defaultGradeValue\": 3}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*\", \"defaultGradeValue\": 4}], \"gradeEntries\": [{\"rankCapValue\": 50, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 60, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 70, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 80, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}]}]}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.update_current_grade_master(
        grade.UpdateCurrentGradeMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{"version": "2023-12-25", "gradeModels": [{"name": "grade-0001", "metadata": "GRADE_0001", "experienceModelId": "grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001", "defaultGrades": [{"propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*", "defaultGradeValue": 2}, {"propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*", "defaultGradeValue": 3}, {"propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*", "defaultGradeValue": 4}], "gradeEntries": [{"rankCapValue": 50, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}, {"rankCapValue": 60, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}, {"rankCapValue": 70, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}, {"rankCapValue": 80, "propertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*", "gradeUpPropertyIdRegex": "grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"}]}]}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.update_current_grade_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-12-25\", \"gradeModels\": [{\"name\": \"grade-0001\", \"metadata\": \"GRADE_0001\", \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001\", \"defaultGrades\": [{\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*\", \"defaultGradeValue\": 2}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*\", \"defaultGradeValue\": 3}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*\", \"defaultGradeValue\": 4}], \"gradeEntries\": [{\"rankCapValue\": 50, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 60, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 70, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 80, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}]}]}",
    uploadToken=nil,
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.update_current_grade_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-12-25\", \"gradeModels\": [{\"name\": \"grade-0001\", \"metadata\": \"GRADE_0001\", \"experienceModelId\": \"grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001\", \"defaultGrades\": [{\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:r-.*\", \"defaultGradeValue\": 2}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:sr-.*\", \"defaultGradeValue\": 3}, {\"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*\", \"defaultGradeValue\": 4}], \"gradeEntries\": [{\"rankCapValue\": 50, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 60, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 70, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}, {\"rankCapValue\": 80, \"propertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*\", \"gradeUpPropertyIdRegex\": \"grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*\"}]}]}",
    uploadToken=nil,
})

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

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

result = api_result.result
item = result.item;

```




---

### updateCurrentGradeMasterFromGitHub

現在アクティブなグレードモデルのマスターデータをGitHubから更新<br>

指定されたGitHubリポジトリからグレードモデルマスターデータをチェックアウトし、有効化します。<br>
チェックアウト設定でリポジトリ、ブランチ/タグ、取得するファイルパスを指定します。<br>
グレード設定がリポジトリでバージョン管理されるGitベースのマスターデータ管理ワークフローを可能にします。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) |  | ✓|  |  | GitHubからマスターデータをチェックアウトする設定 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentGradeMaster](#currentgrademaster) | 更新された現在アクティブなグレードモデルのマスターデータ |

#### 実装例




**Go**
```go

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

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

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

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

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\UpdateCurrentGradeMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->updateCurrentGradeMasterFromGitHub(
        (new UpdateCurrentGradeMasterFromGitHubRequest())
            ->withNamespaceName("namespace-0001")
            ->withCheckoutSetting((new GitHubCheckoutSetting())
                ->withApiKeyId("apiKeyId-0001")
                ->withRepositoryName("gs2io/master-data")
                ->withSourcePath("path/to/file.json")
                ->withReferenceType("branch")
                ->withBranchName("develop")
            )
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.UpdateCurrentGradeMasterFromGitHubRequest;
import io.gs2.grade.result.UpdateCurrentGradeMasterFromGitHubResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.UpdateCurrentGradeMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentGradeMasterFromGitHub(
    new Gs2.Gs2Grade.Request.UpdateCurrentGradeMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2Grade.Model.GitHubCheckoutSetting()
            .WithApiKeyId("apiKeyId-0001")
            .WithRepositoryName("gs2io/master-data")
            .WithSourcePath("path/to/file.json")
            .WithReferenceType("branch")
            .WithBranchName("develop")
        ),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.updateCurrentGradeMasterFromGitHub(
        new Gs2Grade.UpdateCurrentGradeMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2Grade.model.GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.update_current_grade_master_from_git_hub(
        grade.UpdateCurrentGradeMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(grade.GitHubCheckoutSetting()
                .with_api_key_id('apiKeyId-0001')
                .with_repository_name('gs2io/master-data')
                .with_source_path('path/to/file.json')
                .with_reference_type('branch')
                .with_branch_name('develop')
            )
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

result = api_result.result
item = result.item;

```




---

### describeGradeModelMasters

グレードモデルマスターの一覧を取得<br>

名前の接頭辞フィルタリングが可能な、編集可能なグレードモデルマスターのページネーション付きリストを取得します。<br>
グレードモデルマスターはグレードエントリ、デフォルトグレード、リンクされたエクスペリエンスモデル、入手アクションレートを含むグレード構造を定義します。<br>
マスターへの変更は、CurrentGradeMaster API でマスターデータを有効化するまで反映されません。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string |  | |  |  ~ 64文字 | グレードモデル名のフィルター接頭辞 |
| pageToken | string |  | |  |  ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int |  | | 30 | 1 ~ 1000 | データの取得件数 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;GradeModelMaster&gt;](#grademodelmaster) | グレードモデルマスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.DescribeGradeModelMasters(
    &grade.DescribeGradeModelMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        NamePrefix: nil,
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DescribeGradeModelMastersRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

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

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.DescribeGradeModelMastersRequest;
import io.gs2.grade.result.DescribeGradeModelMastersResult;

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

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

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

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


```

**GS2-Script**
```lua

client = gs2('grade')

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

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

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

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

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

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

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

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

```




---

### createGradeModelMaster

グレードモデルマスターを新規作成<br>

新しい編集可能なグレードモデルマスター定義を作成します。<br>
主な設定項目：<br>
- defaultGrades: 新規ユーザーの初期グレード値<br>
- experienceModelId: ランクキャップ管理のために GS2-Experience モデルにリンク<br>
- gradeEntries: 各グレードレベルのランクキャップ値とプロパティIDマッチングパターンを定義<br>
- acquireActionRates: 現在のグレードに基づいて入手アクションに適用されるレート乗数<br>
変更は CurrentGradeMaster API でマスターデータを有効化するまで反映されません。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string |  | ✓|  |  ~ 128文字 | グレードモデル名 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| defaultGrades | [List&lt;DefaultGradeModel&gt;](#defaultgrademodel) |  | |  | 0 ~ 100 items | デフォルトグレードモデルリスト<br>新規ステータス作成時に評価されるデフォルトグレードルールの順序付きリストです。各エントリはプロパティIDの正規表現パターンとマッチした場合に割り当てるグレード値を定義します。どのパターンにもマッチしない場合はデフォルトのグレード値 0 が使用されます。 |
| experienceModelId | string |  | ✓|  |  ~ 1024文字 | GS2-Experience 経験値モデルGRN<br>このグレードモデルと連動させる GS2-Experience の経験値モデルの GRN です。グレード値が変更されると、グレードエントリのマッピングに基づいて連動する経験値モデルのランクキャップが自動的に更新されます。これにより、高いグレードが高いランクキャップを解放するグレード駆動の成長が実現できます。 |
| gradeEntries | [List&lt;GradeEntryModel&gt;](#gradeentrymodel) |  | |  | 0 ~ 100 items | グレードエントリーモデルリスト<br>各グレード値を連動する GS2-Experience モデルのランクキャップにマッピングするグレードエントリの順序付きリストです。配列のインデックスがグレード値に対応し、最初のエントリ（インデックス 0）がグレード 0 のランクキャップを、2番目がグレード 1 を定義します。 |
| acquireActionRates | [List&lt;AcquireActionRate&gt;](#acquireactionrate) |  | |  | 0 ~ 100 items | 報酬加算テーブルリスト<br>グレードに基づいて報酬量をスケーリングするための名前付き倍率テーブルのコレクションです。複数のテーブルを定義して、異なる種類の報酬（例: 経験値、通貨、アイテム）に異なるスケーリングルールを適用できます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [GradeModelMaster](#grademodelmaster) | 作成したグレードモデルマスター |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.CreateGradeModelMaster(
    &grade.CreateGradeModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("grade-model-0001"),
        Description: nil,
        Metadata: nil,
        DefaultGrades: []grade.DefaultGradeModel{
            grade.DefaultGradeModel{
                PropertyIdRegex: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*"),
                DefaultGradeValue: pointy.Int64(2),
            },
        },
        ExperienceModelId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001"),
        GradeEntries: []grade.GradeEntryModel{
            grade.GradeEntryModel{
                Metadata: pointy.String("GRADE_ENTRY_METADATA"),
                RankCapValue: pointy.Int64(50),
                PropertyIdRegex: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*"),
                GradeUpPropertyIdRegex: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"),
            },
        },
        AcquireActionRates: []grade.AcquireActionRate{
            grade.AcquireActionRate{
                Name: pointy.String("rate-0001"),
                Rates: []*float64{
                    pointy.Float64(1.0),
                    pointy.Float64(1.5),
                    pointy.Float64(2.0),
                },
            },
            grade.AcquireActionRate{
                Name: pointy.String("rate-0002"),
                Rates: []*float64{
                    pointy.Float64(10.0),
                    pointy.Float64(15.5),
                    pointy.Float64(20.0),
                },
            },
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\CreateGradeModelMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->createGradeModelMaster(
        (new CreateGradeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("grade-model-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withDefaultGrades([
                (new \Gs2\Grade\Model\DefaultGradeModel())
                    ->withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*")
                    ->withDefaultGradeValue(2),
            ])
            ->withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
            ->withGradeEntries([
                (new \Gs2\Grade\Model\GradeEntryModel())
                    ->withMetadata("GRADE_ENTRY_METADATA")
                    ->withRankCapValue(50)
                    ->withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*")
                    ->withGradeUpPropertyIdRegex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*'),
            ])
            ->withAcquireActionRates([
                (new \Gs2\Grade\Model\AcquireActionRate())
                    ->withName("rate-0001")
                    ->withRates([
                        1.0,
                        1.5,
                        2.0,
                    ]),
                (new \Gs2\Grade\Model\AcquireActionRate())
                    ->withName("rate-0002")
                    ->withRates([
                        10.0,
                        15.5,
                        20.0,
                    ]),
            ])
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.CreateGradeModelMasterRequest;
import io.gs2.grade.result.CreateGradeModelMasterResult;

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

try {
    CreateGradeModelMasterResult result = client.createGradeModelMaster(
        new CreateGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("grade-model-0001")
            .withDescription(null)
            .withMetadata(null)
            .withDefaultGrades(Arrays.asList(
                new io.gs2.grade.model.DefaultGradeModel()
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*")
                    .withDefaultGradeValue(2L)
            ))
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
            .withGradeEntries(Arrays.asList(
                new io.gs2.grade.model.GradeEntryModel()
                    .withMetadata("GRADE_ENTRY_METADATA")
                    .withRankCapValue(50L)
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*")
                    .withGradeUpPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*")
            ))
            .withAcquireActionRates(Arrays.asList(
                new io.gs2.grade.model.AcquireActionRate()
                    .withName("rate-0001")
                    .withRates(Arrays.asList(
                        1.0,
                        1.5,
                        2.0
                    )),
                new io.gs2.grade.model.AcquireActionRate()
                    .withName("rate-0002")
                    .withRates(Arrays.asList(
                        10.0,
                        15.5,
                        20.0
                    ))
            ))
    );
    GradeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.CreateGradeModelMasterResult> asyncResult = null;
yield return client.CreateGradeModelMaster(
    new Gs2.Gs2Grade.Request.CreateGradeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("grade-model-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithDefaultGrades(new Gs2.Gs2Grade.Model.DefaultGradeModel[] {
            new Gs2.Gs2Grade.Model.DefaultGradeModel()
                .WithPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*")
                .WithDefaultGradeValue(2L),
        })
        .WithExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
        .WithGradeEntries(new Gs2.Gs2Grade.Model.GradeEntryModel[] {
            new Gs2.Gs2Grade.Model.GradeEntryModel()
                .WithMetadata("GRADE_ENTRY_METADATA")
                .WithRankCapValue(50L)
                .WithPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*")
                .WithGradeUpPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"),
        })
        .WithAcquireActionRates(new Gs2.Gs2Grade.Model.AcquireActionRate[] {
            new Gs2.Gs2Grade.Model.AcquireActionRate()
                .WithName("rate-0001")
                .WithRates(new double[] {
                    1.0,
                    1.5,
                    2.0,
                }),
            new Gs2.Gs2Grade.Model.AcquireActionRate()
                .WithName("rate-0002")
                .WithRates(new double[] {
                    10.0,
                    15.5,
                    20.0,
                }),
        }),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.createGradeModelMaster(
        new Gs2Grade.CreateGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("grade-model-0001")
            .withDescription(null)
            .withMetadata(null)
            .withDefaultGrades([
                new Gs2Grade.model.DefaultGradeModel()
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*")
                    .withDefaultGradeValue(2),
            ])
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
            .withGradeEntries([
                new Gs2Grade.model.GradeEntryModel()
                    .withMetadata("GRADE_ENTRY_METADATA")
                    .withRankCapValue(50)
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*")
                    .withGradeUpPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*"),
            ])
            .withAcquireActionRates([
                new Gs2Grade.model.AcquireActionRate()
                    .withName("rate-0001")
                    .withRates([
                        1.0,
                        1.5,
                        2.0,
                    ]),
                new Gs2Grade.model.AcquireActionRate()
                    .withName("rate-0002")
                    .withRates([
                        10.0,
                        15.5,
                        20.0,
                    ]),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.create_grade_model_master(
        grade.CreateGradeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('grade-model-0001')
            .with_description(None)
            .with_metadata(None)
            .with_default_grades([
                grade.DefaultGradeModel()
                    .with_property_id_regex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*')
                    .with_default_grade_value(2),
            ])
            .with_experience_model_id('grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001')
            .with_grade_entries([
                grade.GradeEntryModel()
                    .with_metadata('GRADE_ENTRY_METADATA')
                    .with_rank_cap_value(50)
                    .with_property_id_regex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*')
                    .with_grade_up_property_id_regex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*'),
            ])
            .with_acquire_action_rates([
                grade.AcquireActionRate()
                    .with_name('rate-0001')
                    .with_rates([
                        1.0,
                        1.5,
                        2.0,
                    ]),
                grade.AcquireActionRate()
                    .with_name('rate-0002')
                    .with_rates([
                        10.0,
                        15.5,
                        20.0,
                    ]),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.create_grade_model_master({
    namespaceName="namespace-0001",
    name="grade-model-0001",
    description=nil,
    metadata=nil,
    defaultGrades={
        {
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*",
            defaultGradeValue=2,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001",
    gradeEntries={
        {
            metadata="GRADE_ENTRY_METADATA",
            rankCapValue=50,
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*",
            gradeUpPropertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*",
        }
    },
    acquireActionRates={
        {
            name="rate-0001",
            rates={
                1.0,
                1.5,
                2.0
            },
        },
        {
            name="rate-0002",
            rates={
                10.0,
                15.5,
                20.0
            },
        }
    },
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.create_grade_model_master_async({
    namespaceName="namespace-0001",
    name="grade-model-0001",
    description=nil,
    metadata=nil,
    defaultGrades={
        {
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:ssr-.*",
            defaultGradeValue=2,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001",
    gradeEntries={
        {
            metadata="GRADE_ENTRY_METADATA",
            rankCapValue=50,
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:(.*):.*",
            gradeUpPropertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0001:item:$1:.*",
        }
    },
    acquireActionRates={
        {
            name="rate-0001",
            rates={
                1.0,
                1.5,
                2.0
            },
        },
        {
            name="rate-0002",
            rates={
                10.0,
                15.5,
                20.0
            },
        }
    },
})

api_result = 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;

```




---

### getGradeModelMaster

グレードモデルマスターを取得<br>

名前を指定して、特定の編集可能なグレードモデルマスターの詳細情報を取得します。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [GradeModelMaster](#grademodelmaster) | グレードモデルマスター |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.GetGradeModelMaster(
    &grade.GetGradeModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        GradeName: pointy.String("grade-model-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\GetGradeModelMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->getGradeModelMaster(
        (new GetGradeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withGradeName("grade-model-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.GetGradeModelMasterRequest;
import io.gs2.grade.result.GetGradeModelMasterResult;

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

try {
    GetGradeModelMasterResult result = client.getGradeModelMaster(
        new GetGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-model-0001")
    );
    GradeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.GetGradeModelMasterResult> asyncResult = null;
yield return client.GetGradeModelMaster(
    new Gs2.Gs2Grade.Request.GetGradeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithGradeName("grade-model-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.getGradeModelMaster(
        new Gs2Grade.GetGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-model-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.get_grade_model_master(
        grade.GetGradeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_grade_name('grade-model-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.get_grade_model_master({
    namespaceName="namespace-0001",
    gradeName="grade-model-0001",
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.get_grade_model_master_async({
    namespaceName="namespace-0001",
    gradeName="grade-model-0001",
})

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

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

result = api_result.result
item = result.item;

```




---

### updateGradeModelMaster

グレードモデルマスターを更新<br>

既存のグレードモデルマスターの説明、メタデータ、デフォルトグレード、エクスペリエンスモデルリンク、グレードエントリ、入手アクションレートを更新します。<br>
グレードモデル名は作成後に変更できません。<br>
変更は CurrentGradeMaster API でマスターデータを再度有効化するまで反映されません。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| defaultGrades | [List&lt;DefaultGradeModel&gt;](#defaultgrademodel) |  | |  | 0 ~ 100 items | デフォルトグレードモデルリスト<br>新規ステータス作成時に評価されるデフォルトグレードルールの順序付きリストです。各エントリはプロパティIDの正規表現パターンとマッチした場合に割り当てるグレード値を定義します。どのパターンにもマッチしない場合はデフォルトのグレード値 0 が使用されます。 |
| experienceModelId | string |  | ✓|  |  ~ 1024文字 | GS2-Experience 経験値モデルGRN<br>このグレードモデルと連動させる GS2-Experience の経験値モデルの GRN です。グレード値が変更されると、グレードエントリのマッピングに基づいて連動する経験値モデルのランクキャップが自動的に更新されます。これにより、高いグレードが高いランクキャップを解放するグレード駆動の成長が実現できます。 |
| gradeEntries | [List&lt;GradeEntryModel&gt;](#gradeentrymodel) |  | |  | 0 ~ 100 items | グレードエントリーモデルリスト<br>各グレード値を連動する GS2-Experience モデルのランクキャップにマッピングするグレードエントリの順序付きリストです。配列のインデックスがグレード値に対応し、最初のエントリ（インデックス 0）がグレード 0 のランクキャップを、2番目がグレード 1 を定義します。 |
| acquireActionRates | [List&lt;AcquireActionRate&gt;](#acquireactionrate) |  | |  | 0 ~ 100 items | 報酬加算テーブルリスト<br>グレードに基づいて報酬量をスケーリングするための名前付き倍率テーブルのコレクションです。複数のテーブルを定義して、異なる種類の報酬（例: 経験値、通貨、アイテム）に異なるスケーリングルールを適用できます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [GradeModelMaster](#grademodelmaster) | 更新したグレードモデルマスター |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.UpdateGradeModelMaster(
    &grade.UpdateGradeModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        GradeName: pointy.String("grade-model-0001"),
        Description: nil,
        Metadata: nil,
        DefaultGrades: []grade.DefaultGradeModel{
            grade.DefaultGradeModel{
                PropertyIdRegex: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*"),
                DefaultGradeValue: pointy.Int64(3),
            },
        },
        ExperienceModelId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001"),
        GradeEntries: []grade.GradeEntryModel{
            grade.GradeEntryModel{
                Metadata: pointy.String("GRADE_ENTRY_METADATA1"),
                RankCapValue: pointy.Int64(60),
                PropertyIdRegex: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*"),
                GradeUpPropertyIdRegex: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*"),
            },
        },
        AcquireActionRates: []grade.AcquireActionRate{
            grade.AcquireActionRate{
                Name: pointy.String("rate-0001"),
                Mode: pointy.String("big"),
                BigRates: []*string{
                    pointy.String("100000000000000"),
                    pointy.String("10000000000000000000000000000"),
                    pointy.String("1000000000000000000000000000000000000000000"),
                },
            },
            grade.AcquireActionRate{
                Name: pointy.String("rate-0002"),
                Mode: pointy.String("big"),
                BigRates: []*string{
                    pointy.String("100000000000000"),
                    pointy.String("10000000000000000000000000000"),
                    pointy.String("1000000000000000000000000000000000000000000"),
                },
            },
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\UpdateGradeModelMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->updateGradeModelMaster(
        (new UpdateGradeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withGradeName("grade-model-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withDefaultGrades([
                (new \Gs2\Grade\Model\DefaultGradeModel())
                    ->withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*")
                    ->withDefaultGradeValue(3),
            ])
            ->withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
            ->withGradeEntries([
                (new \Gs2\Grade\Model\GradeEntryModel())
                    ->withMetadata("GRADE_ENTRY_METADATA1")
                    ->withRankCapValue(60)
                    ->withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*")
                    ->withGradeUpPropertyIdRegex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*'),
            ])
            ->withAcquireActionRates([
                (new \Gs2\Grade\Model\AcquireActionRate())
                    ->withName("rate-0001")
                    ->withMode("big")
                    ->withBigRates([
                        "100000000000000",
                        "10000000000000000000000000000",
                        "1000000000000000000000000000000000000000000",
                    ]),
                (new \Gs2\Grade\Model\AcquireActionRate())
                    ->withName("rate-0002")
                    ->withMode("big")
                    ->withBigRates([
                        "100000000000000",
                        "10000000000000000000000000000",
                        "1000000000000000000000000000000000000000000",
                    ]),
            ])
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.UpdateGradeModelMasterRequest;
import io.gs2.grade.result.UpdateGradeModelMasterResult;

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

try {
    UpdateGradeModelMasterResult result = client.updateGradeModelMaster(
        new UpdateGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-model-0001")
            .withDescription(null)
            .withMetadata(null)
            .withDefaultGrades(Arrays.asList(
                new io.gs2.grade.model.DefaultGradeModel()
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*")
                    .withDefaultGradeValue(3L)
            ))
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
            .withGradeEntries(Arrays.asList(
                new io.gs2.grade.model.GradeEntryModel()
                    .withMetadata("GRADE_ENTRY_METADATA1")
                    .withRankCapValue(60L)
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*")
                    .withGradeUpPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*")
            ))
            .withAcquireActionRates(Arrays.asList(
                new io.gs2.grade.model.AcquireActionRate()
                    .withName("rate-0001")
                    .withMode("big")
                    .withBigRates(Arrays.asList(
                        "100000000000000",
                        "10000000000000000000000000000",
                        "1000000000000000000000000000000000000000000"
                    )),
                new io.gs2.grade.model.AcquireActionRate()
                    .withName("rate-0002")
                    .withMode("big")
                    .withBigRates(Arrays.asList(
                        "100000000000000",
                        "10000000000000000000000000000",
                        "1000000000000000000000000000000000000000000"
                    ))
            ))
    );
    GradeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.UpdateGradeModelMasterResult> asyncResult = null;
yield return client.UpdateGradeModelMaster(
    new Gs2.Gs2Grade.Request.UpdateGradeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithGradeName("grade-model-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithDefaultGrades(new Gs2.Gs2Grade.Model.DefaultGradeModel[] {
            new Gs2.Gs2Grade.Model.DefaultGradeModel()
                .WithPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*")
                .WithDefaultGradeValue(3L),
        })
        .WithExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
        .WithGradeEntries(new Gs2.Gs2Grade.Model.GradeEntryModel[] {
            new Gs2.Gs2Grade.Model.GradeEntryModel()
                .WithMetadata("GRADE_ENTRY_METADATA1")
                .WithRankCapValue(60L)
                .WithPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*")
                .WithGradeUpPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*"),
        })
        .WithAcquireActionRates(new Gs2.Gs2Grade.Model.AcquireActionRate[] {
            new Gs2.Gs2Grade.Model.AcquireActionRate()
                .WithName("rate-0001")
                .WithMode("big")
                .WithBigRates(new string[] {
                    "100000000000000",
                    "10000000000000000000000000000",
                    "1000000000000000000000000000000000000000000",
                }),
            new Gs2.Gs2Grade.Model.AcquireActionRate()
                .WithName("rate-0002")
                .WithMode("big")
                .WithBigRates(new string[] {
                    "100000000000000",
                    "10000000000000000000000000000",
                    "1000000000000000000000000000000000000000000",
                }),
        }),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.updateGradeModelMaster(
        new Gs2Grade.UpdateGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-model-0001")
            .withDescription(null)
            .withMetadata(null)
            .withDefaultGrades([
                new Gs2Grade.model.DefaultGradeModel()
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*")
                    .withDefaultGradeValue(3),
            ])
            .withExperienceModelId("grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001")
            .withGradeEntries([
                new Gs2Grade.model.GradeEntryModel()
                    .withMetadata("GRADE_ENTRY_METADATA1")
                    .withRankCapValue(60)
                    .withPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*")
                    .withGradeUpPropertyIdRegex("grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*"),
            ])
            .withAcquireActionRates([
                new Gs2Grade.model.AcquireActionRate()
                    .withName("rate-0001")
                    .withMode("big")
                    .withBigRates([
                        "100000000000000",
                        "10000000000000000000000000000",
                        "1000000000000000000000000000000000000000000",
                    ]),
                new Gs2Grade.model.AcquireActionRate()
                    .withName("rate-0002")
                    .withMode("big")
                    .withBigRates([
                        "100000000000000",
                        "10000000000000000000000000000",
                        "1000000000000000000000000000000000000000000",
                    ]),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.update_grade_model_master(
        grade.UpdateGradeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_grade_name('grade-model-0001')
            .with_description(None)
            .with_metadata(None)
            .with_default_grades([
                grade.DefaultGradeModel()
                    .with_property_id_regex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*')
                    .with_default_grade_value(3),
            ])
            .with_experience_model_id('grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001')
            .with_grade_entries([
                grade.GradeEntryModel()
                    .with_metadata('GRADE_ENTRY_METADATA1')
                    .with_rank_cap_value(60)
                    .with_property_id_regex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*')
                    .with_grade_up_property_id_regex('grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*'),
            ])
            .with_acquire_action_rates([
                grade.AcquireActionRate()
                    .with_name('rate-0001')
                    .with_mode('big')
                    .with_big_rates([
                        '100000000000000',
                        '10000000000000000000000000000',
                        '1000000000000000000000000000000000000000000',
                    ]),
                grade.AcquireActionRate()
                    .with_name('rate-0002')
                    .with_mode('big')
                    .with_big_rates([
                        '100000000000000',
                        '10000000000000000000000000000',
                        '1000000000000000000000000000000000000000000',
                    ]),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.update_grade_model_master({
    namespaceName="namespace-0001",
    gradeName="grade-model-0001",
    description=nil,
    metadata=nil,
    defaultGrades={
        {
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*",
            defaultGradeValue=3,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001",
    gradeEntries={
        {
            metadata="GRADE_ENTRY_METADATA1",
            rankCapValue=60,
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*",
            gradeUpPropertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*",
        }
    },
    acquireActionRates={
        {
            name="rate-0001",
            mode="big",
            bigRates={
                "100000000000000",
                "10000000000000000000000000000",
                "1000000000000000000000000000000000000000000"
            },
        },
        {
            name="rate-0002",
            mode="big",
            bigRates={
                "100000000000000",
                "10000000000000000000000000000",
                "1000000000000000000000000000000000000000000"
            },
        }
    },
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.update_grade_model_master_async({
    namespaceName="namespace-0001",
    gradeName="grade-model-0001",
    description=nil,
    metadata=nil,
    defaultGrades={
        {
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:ssr-.*",
            defaultGradeValue=3,
        }
    },
    experienceModelId="grn:gs2:ap-northeast-1:YourOwnerId:experience:namespace-0001:model:experience-0001",
    gradeEntries={
        {
            metadata="GRADE_ENTRY_METADATA1",
            rankCapValue=60,
            propertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:(.*):.*",
            gradeUpPropertyIdRegex="grn:gs2:ap-northeast-1:YourOwnerId:inventory:namespace-0001:inventory:inventory-0002:item:$1:.*",
        }
    },
    acquireActionRates={
        {
            name="rate-0001",
            mode="big",
            bigRates={
                "100000000000000",
                "10000000000000000000000000000",
                "1000000000000000000000000000000000000000000"
            },
        },
        {
            name="rate-0002",
            mode="big",
            bigRates={
                "100000000000000",
                "10000000000000000000000000000",
                "1000000000000000000000000000000000000000000"
            },
        }
    },
})

api_result = 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;

```




---

### deleteGradeModelMaster

グレードモデルマスターを削除<br>

編集可能なグレードモデルマスター定義を削除します。<br>
マスターデータのみが影響を受け、現在有効化（公開）されているモデルはマスターデータが再度有効化されるまで影響を受けません。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gradeName | string |  | ✓|  |  ~ 128文字 | グレードモデル名 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [GradeModelMaster](#grademodelmaster) | 削除したグレードモデルマスター |

#### 実装例




**Go**
```go

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

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

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

client := grade.Gs2GradeRestClient{
    Session: &session,
}
result, err := client.DeleteGradeModelMaster(
    &grade.DeleteGradeModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        GradeName: pointy.String("grade-model-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Grade\Gs2GradeRestClient;
use Gs2\Grade\Request\DeleteGradeModelMasterRequest;

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

$session->open();

$client = new Gs2GradeRestClient(
    $session
);

try {
    $result = $client->deleteGradeModelMaster(
        (new DeleteGradeModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withGradeName("grade-model-0001")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.grade.rest.Gs2GradeRestClient;
import io.gs2.grade.request.DeleteGradeModelMasterRequest;
import io.gs2.grade.result.DeleteGradeModelMasterResult;

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

try {
    DeleteGradeModelMasterResult result = client.deleteGradeModelMaster(
        new DeleteGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-model-0001")
    );
    GradeModelMaster item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

```

**C#**
```csharp

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 Gs2GradeRestClient(session);

AsyncResult<Gs2.Gs2Grade.Result.DeleteGradeModelMasterResult> asyncResult = null;
yield return client.DeleteGradeModelMaster(
    new Gs2.Gs2Grade.Request.DeleteGradeModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithGradeName("grade-model-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Grade from '@/gs2/grade';

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

try {
    const result = await client.deleteGradeModelMaster(
        new Gs2Grade.DeleteGradeModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withGradeName("grade-model-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import grade

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

try:
    result = client.delete_grade_model_master(
        grade.DeleteGradeModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_grade_name('grade-model-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('grade')

api_result = client.delete_grade_model_master({
    namespaceName="namespace-0001",
    gradeName="grade-model-0001",
})

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

result = api_result.result
item = result.item;

```

**GS2-Script(Async)**
```lua

client = gs2('grade')

api_result_handler = client.delete_grade_model_master_async({
    namespaceName="namespace-0001",
    gradeName="grade-model-0001",
})

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

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

result = api_result.result
item = result.item;

```




---