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

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

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



## モデル

### Namespace

ネームスペース<br>

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

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



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string |  | ※ |  |  ~ 1024文字 | ネームスペースGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  |  |  |  ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) |  | ✓ |  |  | トランザクション設定<br>このネームスペース内で報酬トランザクションがどのように実行されるかの設定。 |
| receiveScript | [ScriptSetting](#scriptsetting) |  |  |  |  | 報酬を受け取るときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`receive`](../script/#receive) |
| logSetting | [LogSetting](#logsetting) |  |  |  |  | ログの出力設定<br>APIリクエスト・レスポンスのログを GS2-Log に出力するための設定。<br>設定すると、ログインボーナスの操作（受け取り、取り逃がし救済など）がモニタリングと分析のためにログ出力されます。 |
| 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 チェックアウト設定<br>

GitHub リポジトリからマスターデータを直接取得するための設定。<br>
リポジトリ、ファイルパス、ソース参照（コミットハッシュ、ブランチ、またはタグ）を指定して、マスターデータの JSON ファイルを自動的に取得・適用できます。<br>
GitHub API との認証には GS2-Key の GitHub API キーが必要です。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| 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" であれば 必須 |

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




---

### ReceiveStatus

受け取り状態<br>

ユーザーごと・ボーナスモデルごとのログインボーナスの受け取り状態を追跡します。<br>
各エントリがその日の報酬を受け取り済みかどうかを示す真偽値の配列（receivedSteps）を保持します。<br>
また、日次の受け取り資格を判定するために、最後にボーナスを受け取った時刻（lastReceivedAt）を記録します。<br>
receivedSteps はボーナスサイクルの再開時（ストリーミングモードの繰り返し有効時など）にリセットされることがあります。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| receiveStatusId | string |  | ※ |  |  ~ 1024文字 | ログインボーナス受け取り状態GRN<br>※ サーバーが自動で設定 |
| bonusModelName | string |  | ✓ |  |  ~ 128文字 | ボーナスモデル名<br>この受け取り状態が紐づくログインボーナスモデルの名前。<br>ユーザーの受け取り進捗を特定のボーナスモデル定義に関連づけ、どの報酬リストと配布ルールが適用されるかを決定します。 |
| userId | string |  | ✓ |  |  ~ 128文字 | ユーザーID |
| receivedSteps | List&lt;bool&gt; |  |  | [] | 0 ~ 100 items | 受け取りステップ<br>報酬リストの各日に対応する順序付きの真偽値配列。<br>true はユーザーがその日の報酬を受け取り済みであることを示し、false は取り逃がしたか未受け取りであることを示します。<br>配列のインデックスは関連する BonusModel の rewards 配列と対応します。<br>ストリーミングモードで繰り返しが有効な場合、サイクルの再開時にこの配列はリセットされます。 |
| lastReceivedAt | long |  |  |  |  | 最終受け取り時刻<br>ユーザーが最後にログインボーナスを受け取った時刻のタイムスタンプ。<br>ボーナスモデルで定義されたリセット時間に基づき、ユーザーが本日のボーナスを既に受け取り済みかどうかを判定するために使用されます。<br>受け取り状態がクリアされた際（繰り返しモードでのサイクル再開時など）に 0 にリセットされます。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeReceiveStatuses - 受け取り状態一覧を取得
describeReceiveStatusesByUserId - ユーザーIDを指定して受け取り状態一覧を取得
getReceiveStatus - 受け取り状態を取得
getReceiveStatusByUserId - ユーザーIDを指定して受け取り状態を取得
deleteReceiveStatusByUserId - ユーザーIDを指定して受け取り状態のリセット
markReceived - 受け取り済み化
markReceivedByUserId - ユーザーIDを指定して受け取り済み化
unmarkReceivedByUserId - ユーザーIDを指定して未受け取り化




---

### BonusModel

ログインボーナスモデル<br>

ログインボーナスモデルにはログインボーナスの配布スケジュールを設定します。<br>
配布スケジュールには《スケジュールモード》と《ストリーミングモード》があります。<br>

スケジュールモードでは、GS2-Schedule のイベントの指定が必須で、そのイベントの開始日からの経過日数でボーナスの配布を行います。<br>
途中で取り逃がしが発生した場合、その分のボーナスは配布されません。<br>

ストリーミングモードでは、毎日ボーナスに設定された報酬を先頭から順番に配布します。<br>
ストリーミングモードでは繰り返しの設定が可能です。その場合、ストリームの終端に達した場合、先頭から再度配布を行います。<br>

スケジュールモード・ストリーミングモード 共に、取り逃がしの救済機能があります。<br>
一定のコストを支払うことで、取り逃がしたボーナスを受け取ることができます。<br>
ただし、GS2-Schedule のイベントが関連づけられている場合、イベントの開始日からの経過日数より先のボーナスは受け取ることができません。<br>
取り逃がし救済機能はストリーミングモードかつ繰り返しが有効な場合は使用することができません。<br>

スケジュールモード・ストリーミングモード 共に、設定可能なボーナスの最大日数は100日です。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| bonusModelId | string |  | ※ |  |  ~ 1024文字 | ログインボーナスモデルGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string |  |  |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| mode | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"schedule",<br>&nbsp;&nbsp;"streaming"<br>}<br> |  | ✓ |  |  | モード<br>ログインボーナスの配布スケジュールの種類を指定します。<br>「schedule」モードでは、GS2-Schedule のイベント開始日からの経過日数に基づいて報酬が配布されます。<br>「streaming」モードでは、カレンダーの日付に関係なく、毎日先頭から順番に報酬が配布されます。"schedule": スケジュールモード / "streaming": ストリーミングモード /  |
| periodEventId | string |  |  |  |  ~ 1024文字 | 期間イベントGRN<br>ログインボーナスを有効化する期間を表す GS2-Schedule のイベントGRN。<br>スケジュールモードでは必須で、報酬配布の経過日数を計算する起点の開始日を決定します。<br>ストリーミングモードでは省略可能ですが、指定した場合はイベント開始日からの経過日数より先のボーナスは受け取れなくなります。 |
| resetHour | int | {periodEventId} == "" | ✓※ |  | 0 ~ 23 | リセット時間（UTC）<br>受け取りフラグがリセットされる時刻（0-23、UTC）。<br>ログインボーナスにおける日付の切り替わりタイミングを決定します。<br>periodEventId が未指定の場合にのみ必要です。イベントが設定されている場合、リセットタイミングはイベントのスケジュールに従います。<br>※ periodEventId が "" であれば 必須 |
| repeat | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> | {mode} == "streaming" | ✓※ |  |  | 繰り返し<br>全ての報酬を配布し終えた後に、先頭から再度配布を行うかどうか。<br>ストリーミングモードでのみ有効です。有効にすると、最後の報酬を配布した後に最初の報酬に戻ってループします。<br>注意: 繰り返しが有効な場合、取り逃がし救済機能は使用できません。"enabled": 有効 / "disabled": 無効 / <br>※ mode が "streaming" であれば 必須 |
| rewards | [List&lt;Reward&gt;](#reward) |  |  |  | 0 ~ 100 items | 報酬リスト<br>日毎の報酬の順序付きリスト。各エントリは1日分のログインボーナスに対応し、インデックス 0 から順に配布されます。<br>スケジュールモードでは、インデックスはイベント開始日からの経過日数に対応します。<br>ストリーミングモードでは、インデックスはログイン日数に対応します。最大100エントリまで設定可能です。 |
| missedReceiveRelief | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> |  |  | "disabled" |  | 取り逃がし救済機能<br>取り逃がしたボーナスの救済機能を有効にするかどうか。有効にすると、ユーザーは指定されたコスト（消費アクション）を支払うことで、受け取り損ねたボーナスを遡って受け取ることができます。<br>任意で、救済の許可前に条件を確認する検証アクションも設定できます。<br>ストリーミングモードかつ繰り返しが有効な場合は使用できません。デフォルトは「disabled」です。"enabled": 有効 / "disabled": 無効 /  |
| missedReceiveReliefVerifyActions | [List&lt;VerifyAction&gt;](#verifyaction) | {missedReceiveRelief} == "enabled" |  | [] | 0 ~ 10 items | 取り逃がし救済の検証アクションリスト<br>取り逃がし救済を許可する前に実行される検証アクションのリスト。<br>救済処理の前にユーザーの資格などの前提条件をチェックします。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば 有効 |
| missedReceiveReliefConsumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) | {missedReceiveRelief} == "enabled" |  | [] | 0 ~ 10 items | 取り逃がし救済の消費アクションリスト<br>取り逃がしたボーナスを救済するためにユーザーが支払うコストを定義する消費アクションのリスト。<br>例えば、ゲーム内通貨やアイテムを救済コストとして消費するよう設定できます。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば 有効 |

**関連するメソッド:**
getReceiveStatus - 受け取り状態を取得
getReceiveStatusByUserId - ユーザーIDを指定して受け取り状態を取得
deleteReceiveStatusByUserId - ユーザーIDを指定して受け取り状態のリセット
markReceived - 受け取り済み化
markReceivedByUserId - ユーザーIDを指定して受け取り済み化
unmarkReceivedByUserId - ユーザーIDを指定して未受け取り化
describeBonusModels - ログインボーナスモデルの一覧を取得
getBonusModel - ログインボーナスモデルを取得




---

### Reward

報酬<br>

ログインボーナスの1日分の報酬設定を表します。<br>
各 Reward にはユーザーが受け取るもの（アイテム、通貨、経験値など）を定義する入手アクションのリストが含まれます。<br>
BonusModel の rewards 配列は1日あたり1つの Reward を保持し、順番に配布されます。<br>
報酬の値はバフシステム（BonusModelBuff）を通じて実行時に変更でき、入手アクションにレート乗数を適用できます。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| acquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  | ✓ |  | 1 ~ 10 items | 入手アクションリスト<br>この日の報酬としてユーザーに付与されるリソースを定義する入手アクションのリスト。<br>各アクションは入手アクション（アイテム追加、通貨付与など）とそのリクエストパラメータを指定します。<br>報酬あたり最低1個、最大10個のアクションを設定できます。 |

**関連するモデル:**
BonusModel - ログインボーナスモデル
BonusModelMaster - ログインボーナスモデルマスター




---

### ConsumeAction

消費アクション<br>

消費アクションの仕組みを通じてユーザーからリソースを消費するアクションを定義します。<br>
取り逃がしボーナスの救済でユーザーが支払うコスト（通貨の差し引き、アイテムの消費など）を指定するために使用されます。<br>
action フィールドは消費アクションの種類を指定し、request フィールドには対応するリクエストパラメータが含まれます。



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

**関連するモデル:**
BonusModel - ログインボーナスモデル
BonusModelMaster - ログインボーナスモデルマスター




---

### AcquireAction

入手アクション<br>

入手アクションの仕組みを通じてユーザーにリソースを付与するアクションを定義します。<br>
報酬内で使用され、ユーザーが受け取るもの（インベントリへのアイテム追加、通貨の付与、経験値の付与など）を指定します。<br>
action フィールドは入手アクションの種類を指定し、request フィールドには対応するリクエストパラメータが含まれます。



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

**関連するモデル:**
Reward - 報酬




---

### VerifyAction

検証アクション<br>

操作の実行前に条件を検証するアクションを定義します。<br>
取り逃がしボーナスの救済で、救済を許可する前に前提条件（ユーザーの資格、リソースの利用可能性など）を確認するために使用されます。<br>
action フィールドは検証アクションの種類を指定し、request フィールドには対応するリクエストパラメータが含まれます。



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

**関連するモデル:**
BonusModel - ログインボーナスモデル
BonusModelMaster - ログインボーナスモデルマスター




---

### Config

コンフィグ設定<br>

トランザクションの変数に適用する設定値のキーバリューペア。<br>
Config エントリにより、実行時に入手アクションの動的なパラメータ化が可能になります。<br>
例えば、スロット名やその他のコンテキスト依存の値を Config 設定を通じてトランザクションリクエストに注入でき、<br>
マスターデータを変更することなく柔軟な報酬設定を実現できます。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| key | string |  | ✓ |  |  ~ 64文字 | キー<br>トランザクションパラメータ内で置換される変数名。最大64文字。 |
| value | string |  |  |  |  ~ 51200文字 | 値<br>トランザクションパラメータ内で対応するキーに代入される値。最大51,200文字。 |



---

### 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 |  | トランザクション実行中にエラーが発生したかどうか |



---

### CurrentBonusMaster

現在アクティブなログインボーナスモデルのマスターデータ<br>

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

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



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

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




---

### BonusModelMaster

ログインボーナスモデルマスター<br>

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

ログインボーナスモデルにはログインボーナスの配布スケジュールを設定します。<br>
配布スケジュールには《スケジュールモード》と《ストリーミングモード》があります。<br>

スケジュールモードでは、GS2-Schedule のイベントの指定が必須で、そのイベントの開始日からの経過日数でボーナスの配布を行います。<br>
途中で取り逃がしが発生した場合、その分のボーナスは配布されません。<br>

ストリーミングモードでは、毎日ボーナスに設定された報酬を先頭から順番に配布します。<br>
ストリーミングモードでは繰り返しの設定が可能です。その場合、ストリームの終端に達した場合、先頭から再度配布を行います。<br>

スケジュールモード・ストリーミングモード 共に、取り逃がしの救済機能があります。<br>
一定のコストを支払うことで、取り逃がしたボーナスを受け取ることができます。<br>
ただし、GS2-Schedule のイベントが関連づけられている場合、イベントの開始日からの経過日数より先のボーナスは受け取ることができません。<br>
取り逃がし救済機能はストリーミングモードかつ繰り返しが有効な場合は使用することができません。<br>

スケジュールモード・ストリーミングモード 共に、設定可能なボーナスの最大日数は100日です。



|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| bonusModelId | string |  | ※ |  |  ~ 1024文字 | ログインボーナスモデルマスターGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  |  |  |  ~ 1024文字 | 説明文 |
| metadata | string |  |  |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| mode | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"schedule",<br>&nbsp;&nbsp;"streaming"<br>}<br> |  | ✓ |  |  | モード<br>ログインボーナスの配布スケジュールの種類を指定します。<br>「schedule」モードでは、GS2-Schedule のイベント開始日からの経過日数に基づいて報酬が配布されます。<br>「streaming」モードでは、カレンダーの日付に関係なく、毎日先頭から順番に報酬が配布されます。"schedule": スケジュールモード / "streaming": ストリーミングモード /  |
| periodEventId | string |  |  |  |  ~ 1024文字 | 期間イベントGRN<br>ログインボーナスを有効化する期間を表す GS2-Schedule のイベントGRN。<br>スケジュールモードでは必須で、報酬配布の経過日数を計算する起点の開始日を決定します。<br>ストリーミングモードでは省略可能ですが、指定した場合はイベント開始日からの経過日数より先のボーナスは受け取れなくなります。 |
| resetHour | int | {periodEventId} == "" | ✓※ |  | 0 ~ 23 | リセット時間（UTC）<br>受け取りフラグがリセットされる時刻（0-23、UTC）。<br>ログインボーナスにおける日付の切り替わりタイミングを決定します。<br>periodEventId が未指定の場合にのみ必要です。イベントが設定されている場合、リセットタイミングはイベントのスケジュールに従います。<br>※ periodEventId が "" であれば 必須 |
| repeat | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> | {mode} == "streaming" | ✓※ |  |  | 繰り返し<br>全ての報酬を配布し終えた後に、先頭から再度配布を行うかどうか。<br>ストリーミングモードでのみ有効です。有効にすると、最後の報酬を配布した後に最初の報酬に戻ってループします。<br>注意: 繰り返しが有効な場合、取り逃がし救済機能は使用できません。"enabled": 有効 / "disabled": 無効 / <br>※ mode が "streaming" であれば 必須 |
| rewards | [List&lt;Reward&gt;](#reward) |  |  |  | 0 ~ 100 items | 報酬リスト<br>日毎の報酬の順序付きリスト。各エントリは1日分のログインボーナスに対応し、インデックス 0 から順に配布されます。<br>スケジュールモードでは、インデックスはイベント開始日からの経過日数に対応します。<br>ストリーミングモードでは、インデックスはログイン日数に対応します。最大100エントリまで設定可能です。 |
| missedReceiveRelief | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> |  |  | "disabled" |  | 取り逃がし救済機能<br>取り逃がしたボーナスの救済機能を有効にするかどうか。有効にすると、ユーザーは指定されたコスト（消費アクション）を支払うことで、受け取り損ねたボーナスを遡って受け取ることができます。<br>任意で、救済の許可前に条件を確認する検証アクションも設定できます。<br>ストリーミングモードかつ繰り返しが有効な場合は使用できません。デフォルトは「disabled」です。"enabled": 有効 / "disabled": 無効 /  |
| missedReceiveReliefVerifyActions | [List&lt;VerifyAction&gt;](#verifyaction) | {missedReceiveRelief} == "enabled" |  |  | 0 ~ 10 items | 取り逃がし救済の検証アクションリスト<br>取り逃がし救済を許可する前に実行される検証アクションのリスト。<br>救済処理の前にユーザーの資格などの前提条件をチェックします。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば 有効 |
| missedReceiveReliefConsumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) | {missedReceiveRelief} == "enabled" |  |  | 0 ~ 10 items | 取り逃がし救済の消費アクションリスト<br>取り逃がしたボーナスを救済するためにユーザーが支払うコストを定義する消費アクションのリスト。<br>例えば、ゲーム内通貨やアイテムを救済コストとして消費するよう設定できます。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば 有効 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeBonusModelMasters - ログインボーナスモデルマスターの一覧を取得
createBonusModelMaster - ログインボーナスモデルマスターを新規作成
getBonusModelMaster - ログインボーナスモデルマスターを取得
updateBonusModelMaster - ログインボーナスモデルマスターを更新
deleteBonusModelMaster - ログインボーナスモデルマスターを削除




---
## メソッド

### 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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeNamespacesRequest;

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

$session->open();

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

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

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

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

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

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

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

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

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>このネームスペース内で報酬トランザクションがどのように実行されるかの設定。 |
| receiveScript | [ScriptSetting](#scriptsetting) |  | |  |  | 報酬を受け取るときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`receive`](../script/#receive) |
| logSetting | [LogSetting](#logsetting) |  | |  |  | ログの出力設定<br>APIリクエスト・レスポンスのログを GS2-Log に出力するための設定。<br>設定すると、ログインボーナスの操作（受け取り、取り逃がし救済など）がモニタリングと分析のためにログ出力されます。 |

#### Result

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

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &login_reward.CreateNamespaceRequest {
        Name: pointy.String("namespace-0001"),
        Description: nil,
        TransactionSetting: &loginReward.TransactionSetting{
            EnableAutoRun: pointy.Bool(false),
            QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
        },
        ReceiveScript: nil,
        LogSetting: &loginReward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CreateNamespaceRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName("namespace-0001")
            ->withDescription(null)
            ->withTransactionSetting((new \Gs2\LoginReward\Model\TransactionSetting())
                ->withEnableAutoRun(false)
                ->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            ->withReceiveScript(null)
            ->withLogSetting((new \Gs2\LoginReward\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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CreateNamespaceRequest;
import io.gs2.loginReward.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(new io.gs2.loginReward.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            .withReceiveScript(null)
            .withLogSetting(new io.gs2.loginReward.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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2LoginReward.Request.CreateNamespaceRequest()
        .WithName("namespace-0001")
        .WithDescription(null)
        .WithTransactionSetting(new Gs2.Gs2LoginReward.Model.TransactionSetting()
            .WithEnableAutoRun(false)
            .WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
        .WithReceiveScript(null)
        .WithLogSetting(new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.createNamespace(
        new Gs2LoginReward.CreateNamespaceRequest()
            .withName("namespace-0001")
            .withDescription(null)
            .withTransactionSetting(new Gs2LoginReward.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
            .withReceiveScript(null)
            .withLogSetting(new Gs2LoginReward.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 login_reward

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

try:
    result = client.create_namespace(
        login_reward.CreateNamespaceRequest()
            .with_name('namespace-0001')
            .with_description(None)
            .with_transaction_setting(
                login_reward.TransactionSetting()
                    .with_enable_auto_run(False)
                    .with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
            .with_receive_script(None)
            .with_log_setting(
                login_reward.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('login_reward')

api_result = client.create_namespace({
    name="namespace-0001",
    description=nil,
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
    },
    receiveScript=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('login_reward')

api_result_handler = client.create_namespace_async({
    name="namespace-0001",
    description=nil,
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
    },
    receiveScript=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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetNamespaceStatusRequest;

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetNamespaceRequest;

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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>このネームスペース内で報酬トランザクションがどのように実行されるかの設定。 |
| receiveScript | [ScriptSetting](#scriptsetting) |  | |  |  | 報酬を受け取るときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`receive`](../script/#receive) |
| logSetting | [LogSetting](#logsetting) |  | |  |  | ログの出力設定<br>APIリクエスト・レスポンスのログを GS2-Log に出力するための設定。<br>設定すると、ログインボーナスの操作（受け取り、取り逃がし救済など）がモニタリングと分析のためにログ出力されます。 |

#### Result

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

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &login_reward.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Description: pointy.String("description1"),
        TransactionSetting: &loginReward.TransactionSetting{
            EnableAutoRun: pointy.Bool(false),
            QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"),
        },
        ReceiveScript: nil,
        LogSetting: &loginReward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateNamespaceRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName("namespace-0001")
            ->withDescription("description1")
            ->withTransactionSetting((new \Gs2\LoginReward\Model\TransactionSetting())
                ->withEnableAutoRun(false)
                ->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
            ->withReceiveScript(null)
            ->withLogSetting((new \Gs2\LoginReward\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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UpdateNamespaceRequest;
import io.gs2.loginReward.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(new io.gs2.loginReward.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
            .withReceiveScript(null)
            .withLogSetting(new io.gs2.loginReward.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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2LoginReward.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace-0001")
        .WithDescription("description1")
        .WithTransactionSetting(new Gs2.Gs2LoginReward.Model.TransactionSetting()
            .WithEnableAutoRun(false)
            .WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
        .WithReceiveScript(null)
        .WithLogSetting(new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.updateNamespace(
        new Gs2LoginReward.UpdateNamespaceRequest()
            .withNamespaceName("namespace-0001")
            .withDescription("description1")
            .withTransactionSetting(new Gs2LoginReward.model.TransactionSetting()
                .withEnableAutoRun(false)
                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
            .withReceiveScript(null)
            .withLogSetting(new Gs2LoginReward.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 login_reward

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

try:
    result = client.update_namespace(
        login_reward.UpdateNamespaceRequest()
            .with_namespace_name('namespace-0001')
            .with_description('description1')
            .with_transaction_setting(
                login_reward.TransactionSetting()
                    .with_enable_auto_run(False)
                    .with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002'))
            .with_receive_script(None)
            .with_log_setting(
                login_reward.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('login_reward')

api_result = client.update_namespace({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
    },
    receiveScript=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('login_reward')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace-0001",
    description="description1",
    transactionSetting={
        enableAutoRun=false,
        queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
    },
    receiveScript=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;

```




---

### 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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DeleteNamespaceRequest;

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetServiceVersion(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetServiceVersionRequest;

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DumpUserDataByUserId(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DumpUserDataByUserIdRequest;
import io.gs2.loginReward.result.DumpUserDataByUserIdResult;

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

AsyncResult<Gs2.Gs2LoginReward.Result.DumpUserDataByUserIdResult> asyncResult = null;
yield return client.DumpUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CheckDumpUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.loginReward.result.CheckDumpUserDataByUserIdResult;

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

AsyncResult<Gs2.Gs2LoginReward.Result.CheckDumpUserDataByUserIdResult> asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.CleanUserDataByUserId(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CleanUserDataByUserIdRequest;
import io.gs2.loginReward.result.CleanUserDataByUserIdResult;

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

AsyncResult<Gs2.Gs2LoginReward.Result.CleanUserDataByUserIdResult> asyncResult = null;
yield return client.CleanUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CheckCleanUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.loginReward.result.CheckCleanUserDataByUserIdResult;

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

AsyncResult<Gs2.Gs2LoginReward.Result.CheckCleanUserDataByUserIdResult> asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\PrepareImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.loginReward.result.PrepareImportUserDataByUserIdResult;

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

AsyncResult<Gs2.Gs2LoginReward.Result.PrepareImportUserDataByUserIdResult> asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.prepareImportUserDataByUserId(
        new Gs2LoginReward.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 login_reward

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

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

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.ImportUserDataByUserId(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.ImportUserDataByUserIdRequest;
import io.gs2.loginReward.result.ImportUserDataByUserIdResult;

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

AsyncResult<Gs2.Gs2LoginReward.Result.ImportUserDataByUserIdResult> asyncResult = null;
yield return client.ImportUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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

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

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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CheckImportUserDataByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CheckImportUserDataByUserIdRequest;
import io.gs2.loginReward.result.CheckImportUserDataByUserIdResult;

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

AsyncResult<Gs2.Gs2LoginReward.Result.CheckImportUserDataByUserIdResult> asyncResult = null;
yield return client.CheckImportUserDataByUserId(
    new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.checkImportUserDataByUserId(
        new Gs2LoginReward.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 login_reward

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

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

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

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;

```




---

### receive

ログインボーナスを受け取る<br>

指定されたボーナスモデルに基づいて、リクエストしたユーザーのログインボーナスを受け取ります。<br>
ボーナスはステップを通じて進行し、現在のステップの報酬がトランザクションとして発行されます。報酬サイクルが完了しリピートが有効な場合、サイクルは自動的にリセットされます。現在の期間のボーナスが既に受け取り済みの場合、AlreadyReceived エラーが返されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| config | [List&lt;Config&gt;](#config) |  | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |
| 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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.Receive(
    &login_reward.ReceiveRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel
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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ReceiveRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->receive(
        (new ReceiveRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withAccessToken("accessToken-0001")
            ->withConfig(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.ReceiveRequest;
import io.gs2.loginReward.result.ReceiveResult;

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

try {
    ReceiveResult result = client.receive(
        new ReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withConfig(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.ReceiveResult> asyncResult = null;
yield return client.Receive(
    new Gs2.Gs2LoginReward.Request.ReceiveRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001")
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.receive(
        new Gs2LoginReward.ReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withConfig(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    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 login_reward

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

try:
    result = client.receive(
        login_reward.ReceiveRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
            .with_config(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    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('login_reward')

api_result = client.receive({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    config=nil,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;
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('login_reward')

api_result_handler = client.receive_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    config=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;
bonusModel = result.bonusModel;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```




---

### receiveByUserId

ユーザーIDを指定してログインボーナスを受け取る<br>

指定されたユーザーのログインボーナスをボーナスモデルに基づいて受け取ります。<br>
ボーナスはステップを通じて進行し、現在のステップの報酬がトランザクションとして発行されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| config | [List&lt;Config&gt;](#config) |  | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |
| 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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.ReceiveByUserId(
    &login_reward.ReceiveByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        UserId: pointy.String("user-0001"),
        Config: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel
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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ReceiveByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->receiveByUserId(
        (new ReceiveByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.ReceiveByUserIdRequest;
import io.gs2.loginReward.result.ReceiveByUserIdResult;

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

try {
    ReceiveByUserIdResult result = client.receiveByUserId(
        new ReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.ReceiveByUserIdResult> asyncResult = null;
yield return client.ReceiveByUserId(
    new Gs2.Gs2LoginReward.Request.ReceiveByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.receiveByUserId(
        new Gs2LoginReward.ReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    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 login_reward

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

try:
    result = client.receive_by_user_id(
        login_reward.ReceiveByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    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('login_reward')

api_result = client.receive_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    config=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;
bonusModel = result.bonusModel;
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('login_reward')

api_result_handler = client.receive_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    config=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;
bonusModel = result.bonusModel;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```




---

### missedReceive

取り損ねたログインボーナスを受け取る<br>

リクエストしたユーザーの取り損ねたログインボーナスを受け取ります。<br>
ボーナスモデルで取り損ね救済機能が有効になっている必要があります。<br>
ストリーミングモードではステップ番号を自動計算できますが、スケジュールモードではステップ番号を指定する必要があります。<br>
取り損ねた報酬はトランザクションとして発行されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| stepNumber | int |  | |  | 0 ~ 100 | 受け取るステップ番号 ストリーミングモードでは省略が可能です |
| config | [List&lt;Config&gt;](#config) |  | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |
| 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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.MissedReceive(
    &login_reward.MissedReceiveRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        StepNumber: pointy.Int32(1),
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel
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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MissedReceiveRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->missedReceive(
        (new MissedReceiveRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withAccessToken("accessToken-0001")
            ->withStepNumber(1)
            ->withConfig(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MissedReceiveRequest;
import io.gs2.loginReward.result.MissedReceiveResult;

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

try {
    MissedReceiveResult result = client.missedReceive(
        new MissedReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
            .withConfig(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.MissedReceiveResult> asyncResult = null;
yield return client.MissedReceive(
    new Gs2.Gs2LoginReward.Request.MissedReceiveRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001")
        .WithStepNumber(1)
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.missedReceive(
        new Gs2LoginReward.MissedReceiveRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
            .withConfig(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    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 login_reward

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

try:
    result = client.missed_receive(
        login_reward.MissedReceiveRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
            .with_step_number(1)
            .with_config(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    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('login_reward')

api_result = client.missed_receive({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
    config=nil,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;
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('login_reward')

api_result_handler = client.missed_receive_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
    config=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;
bonusModel = result.bonusModel;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```




---

### missedReceiveByUserId

ユーザーIDを指定して取り損ねたログインボーナスを受け取る<br>

指定されたユーザーの取り損ねたログインボーナスを受け取ります。<br>
ボーナスモデルで取り損ね救済機能が有効になっている必要があります。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| stepNumber | int |  | |  | 0 ~ 100 | 受け取るステップ番号 ストリーミングモードでは省略が可能です |
| config | [List&lt;Config&gt;](#config) |  | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |
| 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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.MissedReceiveByUserId(
    &login_reward.MissedReceiveByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        UserId: pointy.String("user-0001"),
        StepNumber: pointy.Int32(1),
        Config: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel
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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MissedReceiveByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->missedReceiveByUserId(
        (new MissedReceiveByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withStepNumber(1)
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MissedReceiveByUserIdRequest;
import io.gs2.loginReward.result.MissedReceiveByUserIdResult;

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

try {
    MissedReceiveByUserIdResult result = client.missedReceiveByUserId(
        new MissedReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
    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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.MissedReceiveByUserIdResult> asyncResult = null;
yield return client.MissedReceiveByUserId(
    new Gs2.Gs2LoginReward.Request.MissedReceiveByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithStepNumber(1)
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;
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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.missedReceiveByUserId(
        new Gs2LoginReward.MissedReceiveByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
    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 login_reward

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

try:
    result = client.missed_receive_by_user_id(
        login_reward.MissedReceiveByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_step_number(1)
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
    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('login_reward')

api_result = client.missed_receive_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    config=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;
bonusModel = result.bonusModel;
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('login_reward')

api_result_handler = client.missed_receive_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    config=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;
bonusModel = result.bonusModel;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```




---

### describeReceiveStatuses

受け取り状態一覧を取得<br>

リクエストしたユーザーのログインボーナス受け取り状態のページネーション付きリストを取得します。<br>
各状態は特定のボーナスモデルに対して、どのステップが受け取り済みかと現在の進捗を追跡します。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;ReceiveStatus&gt;](#receivestatus) | 受け取り状態のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DescribeReceiveStatuses(
    &login_reward.DescribeReceiveStatusesRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeReceiveStatusesRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->describeReceiveStatuses(
        (new DescribeReceiveStatusesRequest())
            ->withNamespaceName("namespace-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeReceiveStatusesRequest;
import io.gs2.loginReward.result.DescribeReceiveStatusesResult;

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

try {
    DescribeReceiveStatusesResult result = client.describeReceiveStatuses(
        new DescribeReceiveStatusesRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<ReceiveStatus> 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 Gs2LoginRewardRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.describeReceiveStatuses(
        new Gs2LoginReward.DescribeReceiveStatusesRequest()
            .withNamespaceName("namespace-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 login_reward

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

try:
    result = client.describe_receive_statuses(
        login_reward.DescribeReceiveStatusesRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.describe_receive_statuses({
    namespaceName="namespace-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('login_reward')

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

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

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

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

```




---

### describeReceiveStatusesByUserId

ユーザーIDを指定して受け取り状態一覧を取得<br>

指定されたユーザーのログインボーナス受け取り状態のページネーション付きリストを取得します。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;ReceiveStatus&gt;](#receivestatus) | 受け取り状態のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DescribeReceiveStatusesByUserId(
    &login_reward.DescribeReceiveStatusesByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeReceiveStatusesByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->describeReceiveStatusesByUserId(
        (new DescribeReceiveStatusesByUserIdRequest())
            ->withNamespaceName("namespace-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeReceiveStatusesByUserIdRequest;
import io.gs2.loginReward.result.DescribeReceiveStatusesByUserIdResult;

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

try {
    DescribeReceiveStatusesByUserIdResult result = client.describeReceiveStatusesByUserId(
        new DescribeReceiveStatusesByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<ReceiveStatus> 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 Gs2LoginRewardRestClient(session);

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

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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

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

```

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

client = gs2('login_reward')

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

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

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

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

```




---

### getReceiveStatus

受け取り状態を取得<br>

リクエストしたユーザーの指定されたボーナスモデルの受け取り状態を取得します。<br>
現在のステップ進捗、受け取り済みステップ、および関連するボーナスモデルの詳細を返します。報酬サイクルが完了しリピートが有効な場合、状態は自動的にリセットされます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ボーナスモデル名<br>この受け取り状態が紐づくログインボーナスモデルの名前。<br>ユーザーの受け取り進捗を特定のボーナスモデル定義に関連づけ、どの報酬リストと配布ルールが適用されるかを決定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetReceiveStatus(
    &login_reward.GetReceiveStatusRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        AccessToken: pointy.String("accessToken-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetReceiveStatusRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getReceiveStatus(
        (new GetReceiveStatusRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withAccessToken("accessToken-0001")
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetReceiveStatusRequest;
import io.gs2.loginReward.result.GetReceiveStatusResult;

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

try {
    GetReceiveStatusResult result = client.getReceiveStatus(
        new GetReceiveStatusRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.GetReceiveStatusResult> asyncResult = null;
yield return client.GetReceiveStatus(
    new Gs2.Gs2LoginReward.Request.GetReceiveStatusRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getReceiveStatus(
        new Gs2LoginReward.GetReceiveStatusRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_receive_status(
        login_reward.GetReceiveStatusRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.get_receive_status({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

```

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

client = gs2('login_reward')

api_result_handler = client.get_receive_status_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
})

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

```




---

### getReceiveStatusByUserId

ユーザーIDを指定して受け取り状態を取得<br>

指定されたユーザーのボーナスモデルの受け取り状態を取得します。ステップ進捗と受け取り済みステップを含みます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ボーナスモデル名<br>この受け取り状態が紐づくログインボーナスモデルの名前。<br>ユーザーの受け取り進捗を特定のボーナスモデル定義に関連づけ、どの報酬リストと配布ルールが適用されるかを決定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetReceiveStatusByUserId(
    &login_reward.GetReceiveStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetReceiveStatusByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getReceiveStatusByUserId(
        (new GetReceiveStatusByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetReceiveStatusByUserIdRequest;
import io.gs2.loginReward.result.GetReceiveStatusByUserIdResult;

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

try {
    GetReceiveStatusByUserIdResult result = client.getReceiveStatusByUserId(
        new GetReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.GetReceiveStatusByUserIdResult> asyncResult = null;
yield return client.GetReceiveStatusByUserId(
    new Gs2.Gs2LoginReward.Request.GetReceiveStatusByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getReceiveStatusByUserId(
        new Gs2LoginReward.GetReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_receive_status_by_user_id(
        login_reward.GetReceiveStatusByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

```

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

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

```




---

### deleteReceiveStatusByUserId

ユーザーIDを指定して受け取り状態のリセット<br>

指定されたユーザーのボーナスモデルの受け取り状態データを全て削除し、ボーナスの進捗を完全にリセットします。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ボーナスモデル名<br>この受け取り状態が紐づくログインボーナスモデルの名前。<br>ユーザーの受け取り進捗を特定のボーナスモデル定義に関連づけ、どの報酬リストと配布ルールが適用されるかを決定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DeleteReceiveStatusByUserId(
    &login_reward.DeleteReceiveStatusByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DeleteReceiveStatusByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->deleteReceiveStatusByUserId(
        (new DeleteReceiveStatusByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DeleteReceiveStatusByUserIdRequest;
import io.gs2.loginReward.result.DeleteReceiveStatusByUserIdResult;

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

try {
    DeleteReceiveStatusByUserIdResult result = client.deleteReceiveStatusByUserId(
        new DeleteReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.DeleteReceiveStatusByUserIdResult> asyncResult = null;
yield return client.DeleteReceiveStatusByUserId(
    new Gs2.Gs2LoginReward.Request.DeleteReceiveStatusByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.deleteReceiveStatusByUserId(
        new Gs2LoginReward.DeleteReceiveStatusByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.delete_receive_status_by_user_id(
        login_reward.DeleteReceiveStatusByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

```

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

client = gs2('login_reward')

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

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

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

```




---

### markReceived

受け取り済み化<br>

リクエストしたユーザーのボーナスモデルで特定のステップを手動で受け取り済みにマークします。<br>
受け取り済みステップのビット配列を更新します。指定されたステップが既に受け取り済みの場合、エラーが返されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ボーナスモデル名<br>この受け取り状態が紐づくログインボーナスモデルの名前。<br>ユーザーの受け取り進捗を特定のボーナスモデル定義に関連づけ、どの報酬リストと配布ルールが適用されるかを決定します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| stepNumber | int |  | ✓|  | 0 ~ 100 | ステップ番号 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.MarkReceived(
    &login_reward.MarkReceivedRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        StepNumber: pointy.Int32(1),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MarkReceivedRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->markReceived(
        (new MarkReceivedRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withAccessToken("accessToken-0001")
            ->withStepNumber(1)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MarkReceivedRequest;
import io.gs2.loginReward.result.MarkReceivedResult;

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

try {
    MarkReceivedResult result = client.markReceived(
        new MarkReceivedRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.MarkReceivedResult> asyncResult = null;
yield return client.MarkReceived(
    new Gs2.Gs2LoginReward.Request.MarkReceivedRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithAccessToken("accessToken-0001")
        .WithStepNumber(1),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.markReceived(
        new Gs2LoginReward.MarkReceivedRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withAccessToken("accessToken-0001")
            .withStepNumber(1)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.mark_received(
        login_reward.MarkReceivedRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_access_token('accessToken-0001')
            .with_step_number(1)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.mark_received({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
})

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

result = api_result.result
item = result.item;
bonusModel = result.bonusModel;

```

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

client = gs2('login_reward')

api_result_handler = client.mark_received_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    accessToken="accessToken-0001",
    stepNumber=1,
})

api_result = 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;
bonusModel = result.bonusModel;

```




---

### markReceivedByUserId

ユーザーIDを指定して受け取り済み化<br>

指定されたユーザーのボーナスモデルで特定のステップを手動で受け取り済みにマークします。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ボーナスモデル名<br>この受け取り状態が紐づくログインボーナスモデルの名前。<br>ユーザーの受け取り進捗を特定のボーナスモデル定義に関連づけ、どの報酬リストと配布ルールが適用されるかを決定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| stepNumber | int |  | ✓|  | 0 ~ 100 | ステップ番号 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.MarkReceivedByUserId(
    &login_reward.MarkReceivedByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        UserId: pointy.String("user-0001"),
        StepNumber: pointy.Int32(1),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\MarkReceivedByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->markReceivedByUserId(
        (new MarkReceivedByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withStepNumber(1)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.MarkReceivedByUserIdRequest;
import io.gs2.loginReward.result.MarkReceivedByUserIdResult;

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

try {
    MarkReceivedByUserIdResult result = client.markReceivedByUserId(
        new MarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.MarkReceivedByUserIdResult> asyncResult = null;
yield return client.MarkReceivedByUserId(
    new Gs2.Gs2LoginReward.Request.MarkReceivedByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithStepNumber(1)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.markReceivedByUserId(
        new Gs2LoginReward.MarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.mark_received_by_user_id(
        login_reward.MarkReceivedByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_step_number(1)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.mark_received_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    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;
bonusModel = result.bonusModel;

```

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

client = gs2('login_reward')

api_result_handler = client.mark_received_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=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
item = result.item;
bonusModel = result.bonusModel;

```




---

### unmarkReceivedByUserId

ユーザーIDを指定して未受け取り化<br>

指定されたユーザーのボーナスモデルで、受け取り済みにマークされたステップを未受け取りに戻します。<br>
指定されたステップが受け取り済みでない場合、エラーが返されます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ボーナスモデル名<br>この受け取り状態が紐づくログインボーナスモデルの名前。<br>ユーザーの受け取り進捗を特定のボーナスモデル定義に関連づけ、どの報酬リストと配布ルールが適用されるかを決定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| stepNumber | int |  | ✓|  | 0 ~ 100 | ステップ番号 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [ReceiveStatus](#receivestatus) | 受け取り状態 |
| bonusModel | [BonusModel](#bonusmodel) | ログインボーナスモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.UnmarkReceivedByUserId(
    &login_reward.UnmarkReceivedByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-0001"),
        UserId: pointy.String("user-0001"),
        StepNumber: pointy.Int32(1),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
bonusModel := result.BonusModel

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UnmarkReceivedByUserIdRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->unmarkReceivedByUserId(
        (new UnmarkReceivedByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-0001")
            ->withUserId("user-0001")
            ->withStepNumber(1)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $bonusModel = $result->getBonusModel();
} 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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UnmarkReceivedByUserIdRequest;
import io.gs2.loginReward.result.UnmarkReceivedByUserIdResult;

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

try {
    UnmarkReceivedByUserIdResult result = client.unmarkReceivedByUserId(
        new UnmarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    ReceiveStatus item = result.getItem();
    BonusModel bonusModel = result.getBonusModel();
} 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.UnmarkReceivedByUserIdResult> asyncResult = null;
yield return client.UnmarkReceivedByUserId(
    new Gs2.Gs2LoginReward.Request.UnmarkReceivedByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-0001")
        .WithUserId("user-0001")
        .WithStepNumber(1)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var bonusModel = result.BonusModel;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.unmarkReceivedByUserId(
        new Gs2LoginReward.UnmarkReceivedByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
            .withUserId("user-0001")
            .withStepNumber(1)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const bonusModel = result.getBonusModel();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.unmark_received_by_user_id(
        login_reward.UnmarkReceivedByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
            .with_user_id('user-0001')
            .with_step_number(1)
            .with_time_offset_token(None)
    )
    item = result.item
    bonus_model = result.bonus_model
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.unmark_received_by_user_id({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=1,
    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;
bonusModel = result.bonusModel;

```

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

client = gs2('login_reward')

api_result_handler = client.unmark_received_by_user_id_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-0001",
    userId="user-0001",
    stepNumber=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
item = result.item;
bonusModel = result.bonusModel;

```




---

### describeBonusModels

ログインボーナスモデルの一覧を取得<br>

指定されたネームスペースの現在アクティブなログインボーナスモデルの一覧を取得します。<br>
モデルはボーナスモード（CUMULATIVE または SCHEDULE）、リセットタイミング、リピート設定、報酬シーケンスを定義します。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;BonusModel&gt;](#bonusmodel) | ログインボーナスモデルのリスト |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DescribeBonusModels(
    &login_reward.DescribeBonusModelsRequest {
        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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeBonusModelsRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->describeBonusModels(
        (new DescribeBonusModelsRequest())
            ->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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeBonusModelsRequest;
import io.gs2.loginReward.result.DescribeBonusModelsResult;

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

try {
    DescribeBonusModelsResult result = client.describeBonusModels(
        new DescribeBonusModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<BonusModel> 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.DescribeBonusModelsResult> asyncResult = null;
yield return client.DescribeBonusModels(
    new Gs2.Gs2LoginReward.Request.DescribeBonusModelsRequest()
        .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 Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.describe_bonus_models(
        login_reward.DescribeBonusModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.describe_bonus_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('login_reward')

api_result_handler = client.describe_bonus_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;

```




---

### getBonusModel

ログインボーナスモデルを取得<br>

指定されたログインボーナスモデルのモード、リセットタイミング、リピート設定、報酬リスト、取り損ね救済設定を含む情報を取得します。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [BonusModel](#bonusmodel) | ログインボーナスモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetBonusModel(
    &login_reward.GetBonusModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonus-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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetBonusModelRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getBonusModel(
        (new GetBonusModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonus-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetBonusModelRequest;
import io.gs2.loginReward.result.GetBonusModelResult;

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

try {
    GetBonusModelResult result = client.getBonusModel(
        new GetBonusModelRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
    );
    BonusModel 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.GetBonusModelResult> asyncResult = null;
yield return client.GetBonusModel(
    new Gs2.Gs2LoginReward.Request.GetBonusModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonus-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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getBonusModel(
        new Gs2LoginReward.GetBonusModelRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonus-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_bonus_model(
        login_reward.GetBonusModelRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonus-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.get_bonus_model({
    namespaceName="namespace-0001",
    bonusModelName="bonus-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('login_reward')

api_result_handler = client.get_bonus_model_async({
    namespaceName="namespace-0001",
    bonusModelName="bonus-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>

現在アクティブなログインボーナスモデルマスターを有効化可能な形式でエクスポートします。<br>
エクスポートされたデータは、他のネームスペースのマスターデータ更新やバックアップとして使用できます。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentBonusMaster](#currentbonusmaster) | 有効化可能なログインボーナスモデルのマスターデータ |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.ExportMaster(
    &login_reward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\ExportMasterRequest;

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

$session->open();

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

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

try {
    ExportMasterResult result = client.exportMaster(
        new ExportMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentBonusMaster 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 Gs2LoginRewardRestClient(session);

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

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


```

**GS2-Script**
```lua

client = gs2('login_reward')

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

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;

```




---

### getCurrentBonusMaster

現在アクティブなログインボーナスモデルのマスターデータを取得<br>

指定されたネームスペースの現在アクティブなログインボーナスモデルのマスターデータを取得します。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentBonusMaster](#currentbonusmaster) | 現在アクティブなログインボーナスモデルのマスターデータ |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetCurrentBonusMaster(
    &login_reward.GetCurrentBonusMasterRequest {
        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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetCurrentBonusMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getCurrentBonusMaster(
        (new GetCurrentBonusMasterRequest())
            ->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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetCurrentBonusMasterRequest;
import io.gs2.loginReward.result.GetCurrentBonusMasterResult;

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

try {
    GetCurrentBonusMasterResult result = client.getCurrentBonusMaster(
        new GetCurrentBonusMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentBonusMaster 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.GetCurrentBonusMasterResult> asyncResult = null;
yield return client.GetCurrentBonusMaster(
    new Gs2.Gs2LoginReward.Request.GetCurrentBonusMasterRequest()
        .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 Gs2LoginReward from '@/gs2/loginReward';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_current_bonus_master(
        login_reward.GetCurrentBonusMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.get_current_bonus_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('login_reward')

api_result_handler = client.get_current_bonus_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;

```




---

### preUpdateCurrentBonusMaster

現在アクティブなログインボーナスモデルのマスターデータを更新（3フェーズ版）<br>

1MBを超えるマスターデータをアップロードする場合は、3フェーズで更新を行います。<br>
1. このAPIを実行し、アップロード用のトークンとURLを取得します。<br>
2. 取得したURLに対して、マスターデータをアップロードします。<br>
3. UpdateCurrentBonusMaster にアップロードで取得したトークンを渡して実行し、マスターデータを反映します。



#### 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/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.PreUpdateCurrentBonusMaster(
    &login_reward.PreUpdateCurrentBonusMasterRequest {
        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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\PreUpdateCurrentBonusMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentBonusMaster(
        (new PreUpdateCurrentBonusMasterRequest())
            ->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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.PreUpdateCurrentBonusMasterRequest;
import io.gs2.loginReward.result.PreUpdateCurrentBonusMasterResult;

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

try {
    PreUpdateCurrentBonusMasterResult result = client.preUpdateCurrentBonusMaster(
        new PreUpdateCurrentBonusMasterRequest()
            .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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.PreUpdateCurrentBonusMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentBonusMaster(
    new Gs2.Gs2LoginReward.Request.PreUpdateCurrentBonusMasterRequest()
        .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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.preUpdateCurrentBonusMaster(
        new Gs2LoginReward.PreUpdateCurrentBonusMasterRequest()
            .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 login_reward

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

try:
    result = client.pre_update_current_bonus_master(
        login_reward.PreUpdateCurrentBonusMasterRequest()
            .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('login_reward')

api_result = client.pre_update_current_bonus_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('login_reward')

api_result_handler = client.pre_update_current_bonus_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;

```




---

### updateCurrentBonusMaster

現在アクティブなログインボーナスモデルのマスターデータを更新<br>

現在アクティブなログインボーナスモデルのマスターデータを更新します。<br>
2つのモードをサポートします：インライン設定用の 'direct' モードと、3フェーズ更新プロセスで事前にアップロードした設定を適用する 'preUpload' モードです。



#### 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 | [CurrentBonusMaster](#currentbonusmaster) | 更新された現在アクティブなログインボーナスモデルのマスターデータ |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentBonusMaster(
    &login_reward.UpdateCurrentBonusMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Mode: pointy.String("direct"),
        Settings: pointy.String("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}"),
        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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateCurrentBonusMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->updateCurrentBonusMaster(
        (new UpdateCurrentBonusMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
            ->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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UpdateCurrentBonusMasterRequest;
import io.gs2.loginReward.result.UpdateCurrentBonusMasterResult;

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

try {
    UpdateCurrentBonusMasterResult result = client.updateCurrentBonusMaster(
        new UpdateCurrentBonusMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
            .withUploadToken(null)
    );
    CurrentBonusMaster 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.UpdateCurrentBonusMasterResult> asyncResult = null;
yield return client.UpdateCurrentBonusMaster(
    new Gs2.Gs2LoginReward.Request.UpdateCurrentBonusMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
        .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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.updateCurrentBonusMaster(
        new Gs2LoginReward.UpdateCurrentBonusMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.update_current_bonus_master(
        login_reward.UpdateCurrentBonusMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{"version": "2023-07-11", "bonusModels": [{"name": "schedule", "mode": "schedule", "periodEventId": "grn:gs2:schedule:grn-0001", "rewards": [{"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}], "missedReceiveRelief": "disabled"}, {"name": "streaming", "mode": "streaming", "resetHour": 15, "repeat": "enabled", "rewards": [{"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}, {"acquireActions": [{"action": "Gs2Stamina:RecoverStaminaByUserId", "request": {"namespaceName": "stamina-0001", "staminaName": "quest", "userId": "#{userId}", "recoverValue": 100}}]}], "missedReceiveRelief": "enabled", "missedReceiveReliefConsumeActions": [{"action": "Gs2Money:WithdrawByUserId", "request": {"namespaceName": "money-0001", "userId": "#{userId}", "slot": 0, "count": 200, "paidOnly": false}}]}]}')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.update_current_bonus_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}",
    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('login_reward')

api_result_handler = client.update_current_bonus_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\"version\": \"2023-07-11\", \"bonusModels\": [{\"name\": \"schedule\", \"mode\": \"schedule\", \"periodEventId\": \"grn:gs2:schedule:grn-0001\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"disabled\"}, {\"name\": \"streaming\", \"mode\": \"streaming\", \"resetHour\": 15, \"repeat\": \"enabled\", \"rewards\": [{\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}, {\"acquireActions\": [{\"action\": \"Gs2Stamina:RecoverStaminaByUserId\", \"request\": {\"namespaceName\": \"stamina-0001\", \"staminaName\": \"quest\", \"userId\": \"#{userId}\", \"recoverValue\": 100}}]}], \"missedReceiveRelief\": \"enabled\", \"missedReceiveReliefConsumeActions\": [{\"action\": \"Gs2Money:WithdrawByUserId\", \"request\": {\"namespaceName\": \"money-0001\", \"userId\": \"#{userId}\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}}]}]}",
    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;

```




---

### updateCurrentBonusMasterFromGitHub

現在アクティブなログインボーナスモデルのマスターデータをGitHubから更新<br>

指定された GitHub リポジトリからマスターデータを取得して、現在アクティブなログインボーナスモデルのマスターデータを更新します。<br>
GS2-Key に保存された API キーが認証に使用され、チェックアウトするブランチ、タグ、またはコミットハッシュを指定できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) |  | ✓|  |  | GitHubからマスターデータをチェックアウトする設定 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentBonusMaster](#currentbonusmaster) | 更新された現在アクティブなログインボーナスモデルのマスターデータ |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentBonusMasterFromGitHub(
    &login_reward.UpdateCurrentBonusMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace-0001"),
        CheckoutSetting: &loginReward.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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateCurrentBonusMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->updateCurrentBonusMasterFromGitHub(
        (new UpdateCurrentBonusMasterFromGitHubRequest())
            ->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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UpdateCurrentBonusMasterFromGitHubRequest;
import io.gs2.loginReward.result.UpdateCurrentBonusMasterFromGitHubResult;

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

try {
    UpdateCurrentBonusMasterFromGitHubResult result = client.updateCurrentBonusMasterFromGitHub(
        new UpdateCurrentBonusMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new GitHubCheckoutSetting()
                .withApiKeyId("apiKeyId-0001")
                .withRepositoryName("gs2io/master-data")
                .withSourcePath("path/to/file.json")
                .withReferenceType("branch")
                .withBranchName("develop")
            )
    );
    CurrentBonusMaster 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.UpdateCurrentBonusMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentBonusMasterFromGitHub(
    new Gs2.Gs2LoginReward.Request.UpdateCurrentBonusMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2LoginReward.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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.updateCurrentBonusMasterFromGitHub(
        new Gs2LoginReward.UpdateCurrentBonusMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2LoginReward.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 login_reward

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

try:
    result = client.update_current_bonus_master_from_git_hub(
        login_reward.UpdateCurrentBonusMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(login_reward.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('login_reward')

api_result = client.update_current_bonus_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('login_reward')

api_result_handler = client.update_current_bonus_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;

```




---

### describeBonusModelMasters

ログインボーナスモデルマスターの一覧を取得<br>

指定されたネームスペースのログインボーナスモデルマスターのページネーション付きリストを取得します。<br>
名前の接頭辞でフィルタリングできます。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;BonusModelMaster&gt;](#bonusmodelmaster) | ログインボーナスモデルマスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DescribeBonusModelMasters(
    &login_reward.DescribeBonusModelMastersRequest {
        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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DescribeBonusModelMastersRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->describeBonusModelMasters(
        (new DescribeBonusModelMastersRequest())
            ->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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DescribeBonusModelMastersRequest;
import io.gs2.loginReward.result.DescribeBonusModelMastersResult;

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

try {
    DescribeBonusModelMastersResult result = client.describeBonusModelMasters(
        new DescribeBonusModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    List<BonusModelMaster> 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.DescribeBonusModelMastersResult> asyncResult = null;
yield return client.DescribeBonusModelMasters(
    new Gs2.Gs2LoginReward.Request.DescribeBonusModelMastersRequest()
        .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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.describeBonusModelMasters(
        new Gs2LoginReward.DescribeBonusModelMastersRequest()
            .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 login_reward

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

try:
    result = client.describe_bonus_model_masters(
        login_reward.DescribeBonusModelMastersRequest()
            .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('login_reward')

api_result = client.describe_bonus_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('login_reward')

api_result_handler = client.describe_bonus_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;

```




---

### createBonusModelMaster

ログインボーナスモデルマスターを新規作成<br>

指定された設定で新しいログインボーナスモデルマスターを作成します。<br>
モードは CUMULATIVE（連続日次ボーナス）または SCHEDULE（イベント期間ベースのボーナス）を指定できます。リセット時間、リピート動作、報酬シーケンス、および検証/消費アクション付きの取り損ね救済を設定できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string |  | ✓|  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| mode | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"schedule",<br>&nbsp;&nbsp;"streaming"<br>}<br> |  | ✓|  |  | モード<br>ログインボーナスの配布スケジュールの種類を指定します。<br>「schedule」モードでは、GS2-Schedule のイベント開始日からの経過日数に基づいて報酬が配布されます。<br>「streaming」モードでは、カレンダーの日付に関係なく、毎日先頭から順番に報酬が配布されます。"schedule": スケジュールモード / "streaming": ストリーミングモード /  |
| periodEventId | string |  | |  |  ~ 1024文字 | 期間イベントGRN<br>ログインボーナスを有効化する期間を表す GS2-Schedule のイベントGRN。<br>スケジュールモードでは必須で、報酬配布の経過日数を計算する起点の開始日を決定します。<br>ストリーミングモードでは省略可能ですが、指定した場合はイベント開始日からの経過日数より先のボーナスは受け取れなくなります。 |
| resetHour | int | {periodEventId} == "" | ✓※|  | 0 ~ 23 | リセット時間（UTC）<br>受け取りフラグがリセットされる時刻（0-23、UTC）。<br>ログインボーナスにおける日付の切り替わりタイミングを決定します。<br>periodEventId が未指定の場合にのみ必要です。イベントが設定されている場合、リセットタイミングはイベントのスケジュールに従います。<br>※ periodEventId が "" であれば必須 |
| repeat | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> | {mode} == "streaming" | ✓※|  |  | 繰り返し<br>全ての報酬を配布し終えた後に、先頭から再度配布を行うかどうか。<br>ストリーミングモードでのみ有効です。有効にすると、最後の報酬を配布した後に最初の報酬に戻ってループします。<br>注意: 繰り返しが有効な場合、取り逃がし救済機能は使用できません。"enabled": 有効 / "disabled": 無効 / <br>※ mode が "streaming" であれば必須 |
| rewards | [List&lt;Reward&gt;](#reward) |  | |  | 0 ~ 100 items | 報酬リスト<br>日毎の報酬の順序付きリスト。各エントリは1日分のログインボーナスに対応し、インデックス 0 から順に配布されます。<br>スケジュールモードでは、インデックスはイベント開始日からの経過日数に対応します。<br>ストリーミングモードでは、インデックスはログイン日数に対応します。最大100エントリまで設定可能です。 |
| missedReceiveRelief | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> |  | | "disabled" |  | 取り逃がし救済機能<br>取り逃がしたボーナスの救済機能を有効にするかどうか。有効にすると、ユーザーは指定されたコスト（消費アクション）を支払うことで、受け取り損ねたボーナスを遡って受け取ることができます。<br>任意で、救済の許可前に条件を確認する検証アクションも設定できます。<br>ストリーミングモードかつ繰り返しが有効な場合は使用できません。デフォルトは「disabled」です。"enabled": 有効 / "disabled": 無効 /  |
| missedReceiveReliefVerifyActions | [List&lt;VerifyAction&gt;](#verifyaction) | {missedReceiveRelief} == "enabled" | |  | 0 ~ 10 items | 取り逃がし救済の検証アクションリスト<br>取り逃がし救済を許可する前に実行される検証アクションのリスト。<br>救済処理の前にユーザーの資格などの前提条件をチェックします。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば有効 |
| missedReceiveReliefConsumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) | {missedReceiveRelief} == "enabled" | |  | 0 ~ 10 items | 取り逃がし救済の消費アクションリスト<br>取り逃がしたボーナスを救済するためにユーザーが支払うコストを定義する消費アクションのリスト。<br>例えば、ゲーム内通貨やアイテムを救済コストとして消費するよう設定できます。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば有効 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [BonusModelMaster](#bonusmodelmaster) | 作成したログインボーナスモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.CreateBonusModelMaster(
    &login_reward.CreateBonusModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("bonusModel-0001"),
        Description: nil,
        Metadata: nil,
        Mode: pointy.String("schedule"),
        PeriodEventId: pointy.String("grn:gs2:schedule:grn-0001"),
        ResetHour: nil,
        Repeat: nil,
        Rewards: []loginReward.Reward{
            loginReward.Reward{
                AcquireActions: []loginReward.AcquireAction{
                    loginReward.AcquireAction{
                        Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
                        Request: pointy.String("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    },
                },
            },
            loginReward.Reward{
                AcquireActions: []loginReward.AcquireAction{
                    loginReward.AcquireAction{
                        Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
                        Request: pointy.String("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    },
                },
            },
            loginReward.Reward{
                AcquireActions: []loginReward.AcquireAction{
                    loginReward.AcquireAction{
                        Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
                        Request: pointy.String("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    },
                },
            },
        },
        MissedReceiveRelief: pointy.String("disabled"),
        MissedReceiveReliefVerifyActions: nil,
        MissedReceiveReliefConsumeActions: 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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\CreateBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->createBonusModelMaster(
        (new CreateBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("bonusModel-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withMode("schedule")
            ->withPeriodEventId("grn:gs2:schedule:grn-0001")
            ->withResetHour(null)
            ->withRepeat(null)
            ->withRewards([
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            ->withMissedReceiveRelief("disabled")
            ->withMissedReceiveReliefVerifyActions(null)
            ->withMissedReceiveReliefConsumeActions(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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.CreateBonusModelMasterRequest;
import io.gs2.loginReward.result.CreateBonusModelMasterResult;

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

try {
    CreateBonusModelMasterResult result = client.createBonusModelMaster(
        new CreateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("bonusModel-0001")
            .withDescription(null)
            .withMetadata(null)
            .withMode("schedule")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat(null)
            .withRewards(Arrays.asList(
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    ))
            ))
            .withMissedReceiveRelief("disabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions(null)
    );
    BonusModelMaster 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.CreateBonusModelMasterResult> asyncResult = null;
yield return client.CreateBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.CreateBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("bonusModel-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithMode("schedule")
        .WithPeriodEventId("grn:gs2:schedule:grn-0001")
        .WithResetHour(null)
        .WithRepeat(null)
        .WithRewards(new Gs2.Gs2LoginReward.Model.Reward[] {
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
        })
        .WithMissedReceiveRelief("disabled")
        .WithMissedReceiveReliefVerifyActions(null)
        .WithMissedReceiveReliefConsumeActions(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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.createBonusModelMaster(
        new Gs2LoginReward.CreateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("bonusModel-0001")
            .withDescription(null)
            .withMetadata(null)
            .withMode("schedule")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat(null)
            .withRewards([
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            .withMissedReceiveRelief("disabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.create_bonus_model_master(
        login_reward.CreateBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('bonusModel-0001')
            .with_description(None)
            .with_metadata(None)
            .with_mode('schedule')
            .with_period_event_id('grn:gs2:schedule:grn-0001')
            .with_reset_hour(None)
            .with_repeat(None)
            .with_rewards([
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
            ])
            .with_missed_receive_relief('disabled')
            .with_missed_receive_relief_verify_actions(None)
            .with_missed_receive_relief_consume_actions(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.create_bonus_model_master({
    namespaceName="namespace-0001",
    name="bonusModel-0001",
    description=nil,
    metadata=nil,
    mode="schedule",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat=nil,
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="disabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions=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('login_reward')

api_result_handler = client.create_bonus_model_master_async({
    namespaceName="namespace-0001",
    name="bonusModel-0001",
    description=nil,
    metadata=nil,
    mode="schedule",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat=nil,
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="disabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions=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;

```




---

### getBonusModelMaster

ログインボーナスモデルマスターを取得<br>

指定されたログインボーナスモデルマスターのモード、リセットタイミング、リピート設定、報酬リスト、取り損ね救済設定を含む情報を取得します。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [BonusModelMaster](#bonusmodelmaster) | ログインボーナスモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.GetBonusModelMaster(
    &login_reward.GetBonusModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonusModel-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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\GetBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->getBonusModelMaster(
        (new GetBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonusModel-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.GetBonusModelMasterRequest;
import io.gs2.loginReward.result.GetBonusModelMasterResult;

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

try {
    GetBonusModelMasterResult result = client.getBonusModelMaster(
        new GetBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    BonusModelMaster 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.GetBonusModelMasterResult> asyncResult = null;
yield return client.GetBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.GetBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonusModel-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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.getBonusModelMaster(
        new Gs2LoginReward.GetBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.get_bonus_model_master(
        login_reward.GetBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonusModel-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.get_bonus_model_master({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-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('login_reward')

api_result_handler = client.get_bonus_model_master_async({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-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;

```




---

### updateBonusModelMaster

ログインボーナスモデルマスターを更新<br>

指定されたログインボーナスモデルマスターを更新します。説明、メタデータ、モード、リセットタイミング、リピート設定、報酬シーケンス、取り損ね救済設定を変更できます。



#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| bonusModelName | string |  | ✓|  |  ~ 128文字 | ログインボーナスモデル名<br>ログインボーナスモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 2048文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| mode | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"schedule",<br>&nbsp;&nbsp;"streaming"<br>}<br> |  | ✓|  |  | モード<br>ログインボーナスの配布スケジュールの種類を指定します。<br>「schedule」モードでは、GS2-Schedule のイベント開始日からの経過日数に基づいて報酬が配布されます。<br>「streaming」モードでは、カレンダーの日付に関係なく、毎日先頭から順番に報酬が配布されます。"schedule": スケジュールモード / "streaming": ストリーミングモード /  |
| periodEventId | string |  | |  |  ~ 1024文字 | 期間イベントGRN<br>ログインボーナスを有効化する期間を表す GS2-Schedule のイベントGRN。<br>スケジュールモードでは必須で、報酬配布の経過日数を計算する起点の開始日を決定します。<br>ストリーミングモードでは省略可能ですが、指定した場合はイベント開始日からの経過日数より先のボーナスは受け取れなくなります。 |
| resetHour | int | {periodEventId} == "" | ✓※|  | 0 ~ 23 | リセット時間（UTC）<br>受け取りフラグがリセットされる時刻（0-23、UTC）。<br>ログインボーナスにおける日付の切り替わりタイミングを決定します。<br>periodEventId が未指定の場合にのみ必要です。イベントが設定されている場合、リセットタイミングはイベントのスケジュールに従います。<br>※ periodEventId が "" であれば必須 |
| repeat | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> | {mode} == "streaming" | ✓※|  |  | 繰り返し<br>全ての報酬を配布し終えた後に、先頭から再度配布を行うかどうか。<br>ストリーミングモードでのみ有効です。有効にすると、最後の報酬を配布した後に最初の報酬に戻ってループします。<br>注意: 繰り返しが有効な場合、取り逃がし救済機能は使用できません。"enabled": 有効 / "disabled": 無効 / <br>※ mode が "streaming" であれば必須 |
| rewards | [List&lt;Reward&gt;](#reward) |  | |  | 0 ~ 100 items | 報酬リスト<br>日毎の報酬の順序付きリスト。各エントリは1日分のログインボーナスに対応し、インデックス 0 から順に配布されます。<br>スケジュールモードでは、インデックスはイベント開始日からの経過日数に対応します。<br>ストリーミングモードでは、インデックスはログイン日数に対応します。最大100エントリまで設定可能です。 |
| missedReceiveRelief | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"enabled",<br>&nbsp;&nbsp;"disabled"<br>}<br> |  | | "disabled" |  | 取り逃がし救済機能<br>取り逃がしたボーナスの救済機能を有効にするかどうか。有効にすると、ユーザーは指定されたコスト（消費アクション）を支払うことで、受け取り損ねたボーナスを遡って受け取ることができます。<br>任意で、救済の許可前に条件を確認する検証アクションも設定できます。<br>ストリーミングモードかつ繰り返しが有効な場合は使用できません。デフォルトは「disabled」です。"enabled": 有効 / "disabled": 無効 /  |
| missedReceiveReliefVerifyActions | [List&lt;VerifyAction&gt;](#verifyaction) | {missedReceiveRelief} == "enabled" | |  | 0 ~ 10 items | 取り逃がし救済の検証アクションリスト<br>取り逃がし救済を許可する前に実行される検証アクションのリスト。<br>救済処理の前にユーザーの資格などの前提条件をチェックします。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば有効 |
| missedReceiveReliefConsumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) | {missedReceiveRelief} == "enabled" | |  | 0 ~ 10 items | 取り逃がし救済の消費アクションリスト<br>取り逃がしたボーナスを救済するためにユーザーが支払うコストを定義する消費アクションのリスト。<br>例えば、ゲーム内通貨やアイテムを救済コストとして消費するよう設定できます。最大10個まで設定できます。<br>missedReceiveRelief が有効な場合にのみ適用されます。<br>※ missedReceiveRelief が "enabled" であれば有効 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [BonusModelMaster](#bonusmodelmaster) | 更新したログインボーナスモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.UpdateBonusModelMaster(
    &login_reward.UpdateBonusModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonusModel-0001"),
        Description: pointy.String("description1"),
        Metadata: nil,
        Mode: pointy.String("streaming"),
        PeriodEventId: pointy.String("grn:gs2:schedule:grn-0001"),
        ResetHour: nil,
        Repeat: pointy.String("disabled"),
        Rewards: []loginReward.Reward{
            loginReward.Reward{
                AcquireActions: []loginReward.AcquireAction{
                    loginReward.AcquireAction{
                        Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
                        Request: pointy.String("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    },
                },
            },
            loginReward.Reward{
                AcquireActions: []loginReward.AcquireAction{
                    loginReward.AcquireAction{
                        Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
                        Request: pointy.String("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    },
                },
            },
            loginReward.Reward{
                AcquireActions: []loginReward.AcquireAction{
                    loginReward.AcquireAction{
                        Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
                        Request: pointy.String("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    },
                },
            },
        },
        MissedReceiveRelief: pointy.String("enabled"),
        MissedReceiveReliefVerifyActions: nil,
        MissedReceiveReliefConsumeActions: []loginReward.ConsumeAction{
            loginReward.ConsumeAction{
                Action: pointy.String("Gs2Money:WithdrawByUserId"),
                Request: pointy.String("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
            },
        },
    }
)
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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\UpdateBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->updateBonusModelMaster(
        (new UpdateBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonusModel-0001")
            ->withDescription("description1")
            ->withMetadata(null)
            ->withMode("streaming")
            ->withPeriodEventId("grn:gs2:schedule:grn-0001")
            ->withResetHour(null)
            ->withRepeat("disabled")
            ->withRewards([
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                (new \Gs2\LoginReward\Model\Reward())
                    ->withAcquireActions([
                        (new \Gs2\LoginReward\Model\AcquireAction())
                            ->withAction("Gs2Stamina:RecoverStaminaByUserId")
                            ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            ->withMissedReceiveRelief("enabled")
            ->withMissedReceiveReliefVerifyActions(null)
            ->withMissedReceiveReliefConsumeActions([
                (new \Gs2\LoginReward\Model\ConsumeAction())
                    ->withAction("Gs2Money:WithdrawByUserId")
                    ->withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
            ])
    );
    $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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.UpdateBonusModelMasterRequest;
import io.gs2.loginReward.result.UpdateBonusModelMasterResult;

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

try {
    UpdateBonusModelMasterResult result = client.updateBonusModelMaster(
        new UpdateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withMode("streaming")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat("disabled")
            .withRewards(Arrays.asList(
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    )),
                new io.gs2.loginReward.model.Reward()
                    .withAcquireActions(Arrays.asList(
                        new io.gs2.loginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
                    ))
            ))
            .withMissedReceiveRelief("enabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions(Arrays.asList(
                new io.gs2.loginReward.model.ConsumeAction()
                    .withAction("Gs2Money:WithdrawByUserId")
                    .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}")
            ))
    );
    BonusModelMaster 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.UpdateBonusModelMasterResult> asyncResult = null;
yield return client.UpdateBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.UpdateBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonusModel-0001")
        .WithDescription("description1")
        .WithMetadata(null)
        .WithMode("streaming")
        .WithPeriodEventId("grn:gs2:schedule:grn-0001")
        .WithResetHour(null)
        .WithRepeat("disabled")
        .WithRewards(new Gs2.Gs2LoginReward.Model.Reward[] {
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
            new Gs2.Gs2LoginReward.Model.Reward()
                .WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Stamina:RecoverStaminaByUserId")
                        .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                }),
        })
        .WithMissedReceiveRelief("enabled")
        .WithMissedReceiveReliefVerifyActions(null)
        .WithMissedReceiveReliefConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
            new Gs2.Core.Model.ConsumeAction()
                .WithAction("Gs2Money:WithdrawByUserId")
                .WithRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
        }),
    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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.updateBonusModelMaster(
        new Gs2LoginReward.UpdateBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withMode("streaming")
            .withPeriodEventId("grn:gs2:schedule:grn-0001")
            .withResetHour(null)
            .withRepeat("disabled")
            .withRewards([
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
                new Gs2LoginReward.model.Reward()
                    .withAcquireActions([
                        new Gs2LoginReward.model.AcquireAction()
                            .withAction("Gs2Stamina:RecoverStaminaByUserId")
                            .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
                    ]),
            ])
            .withMissedReceiveRelief("enabled")
            .withMissedReceiveReliefVerifyActions(null)
            .withMissedReceiveReliefConsumeActions([
                new Gs2LoginReward.model.ConsumeAction()
                    .withAction("Gs2Money:WithdrawByUserId")
                    .withRequest("{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
            ])
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.update_bonus_model_master(
        login_reward.UpdateBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonusModel-0001')
            .with_description('description1')
            .with_metadata(None)
            .with_mode('streaming')
            .with_period_event_id('grn:gs2:schedule:grn-0001')
            .with_reset_hour(None)
            .with_repeat('disabled')
            .with_rewards([
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
                login_reward.Reward()
                    .with_acquire_actions([
                        login_reward.AcquireAction()
                            .with_action('Gs2Stamina:RecoverStaminaByUserId')
                            .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
                    ]),
            ])
            .with_missed_receive_relief('enabled')
            .with_missed_receive_relief_verify_actions(None)
            .with_missed_receive_relief_consume_actions([
                login_reward.ConsumeAction()
                    .with_action('Gs2Money:WithdrawByUserId')
                    .with_request('{"namespaceName": "stamina-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'),
            ])
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.update_bonus_model_master({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
    description="description1",
    metadata=nil,
    mode="streaming",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat="disabled",
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="enabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions={
        {
            action="Gs2Money:WithdrawByUserId",
            request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
        }
    },
})

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

api_result_handler = client.update_bonus_model_master_async({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-0001",
    description="description1",
    metadata=nil,
    mode="streaming",
    periodEventId="grn:gs2:schedule:grn-0001",
    resetHour=nil,
    repeat="disabled",
    rewards={
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        },
        {
            acquireActions={
                {
                    action="Gs2Stamina:RecoverStaminaByUserId",
                    request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
                }
            },
        }
    },
    missedReceiveRelief="enabled",
    missedReceiveReliefVerifyActions=nil,
    missedReceiveReliefConsumeActions={
        {
            action="Gs2Money:WithdrawByUserId",
            request="{\"namespaceName\": \"stamina-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
        }
    },
})

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

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

result = api_result.result
item = result.item;

```




---

### deleteBonusModelMaster

ログインボーナスモデルマスターを削除<br>

指定されたログインボーナスモデルマスターを削除します。<br>
次のマスターデータ更新まで、現在アクティブなマスターデータには影響しません。



#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [BonusModelMaster](#bonusmodelmaster) | 削除したログインボーナスモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/loginReward"
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 := login_reward.Gs2LoginRewardRestClient{
    Session: &session,
}
result, err := client.DeleteBonusModelMaster(
    &login_reward.DeleteBonusModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        BonusModelName: pointy.String("bonusModel-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\LoginReward\Gs2LoginRewardRestClient;
use Gs2\LoginReward\Request\DeleteBonusModelMasterRequest;

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

$session->open();

$client = new Gs2LoginRewardRestClient(
    $session
);

try {
    $result = $client->deleteBonusModelMaster(
        (new DeleteBonusModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withBonusModelName("bonusModel-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.loginReward.rest.Gs2LoginRewardRestClient;
import io.gs2.loginReward.request.DeleteBonusModelMasterRequest;
import io.gs2.loginReward.result.DeleteBonusModelMasterResult;

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

try {
    DeleteBonusModelMasterResult result = client.deleteBonusModelMaster(
        new DeleteBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    BonusModelMaster 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 Gs2LoginRewardRestClient(session);

AsyncResult<Gs2.Gs2LoginReward.Result.DeleteBonusModelMasterResult> asyncResult = null;
yield return client.DeleteBonusModelMaster(
    new Gs2.Gs2LoginReward.Request.DeleteBonusModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithBonusModelName("bonusModel-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 Gs2LoginReward from '@/gs2/loginReward';

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

try {
    const result = await client.deleteBonusModelMaster(
        new Gs2LoginReward.DeleteBonusModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withBonusModelName("bonusModel-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import login_reward

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

try:
    result = client.delete_bonus_model_master(
        login_reward.DeleteBonusModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_bonus_model_name('bonusModel-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('login_reward')

api_result = client.delete_bonus_model_master({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-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('login_reward')

api_result_handler = client.delete_bonus_model_master_async({
    namespaceName="namespace-0001",
    bonusModelName="bonusModel-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;

```




---