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

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

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



## モデル

### Namespace

ネームスペース<br>

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

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


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string |  | ※ |  |  ~ 1024文字 | ネームスペースGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  |  |  |  ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) |  | ✓ |  |  | トランザクション設定<br>クエスト報酬の付与時のトランザクションの処理方法を制御する設定です。 |
| startQuestScript | [ScriptSetting](#scriptsetting) |  |  |  |  | クエスト開始したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`startQuest`](../script/#startquest) |
| completeQuestScript | [ScriptSetting](#scriptsetting) |  |  |  |  | クエストクリアしたときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`completeQuest`](../script/#completequest) |
| failedQuestScript | [ScriptSetting](#scriptsetting) |  |  |  |  | クエスト失敗したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`failedQuest`](../script/#failedquest) |
| logSetting | [LogSetting](#logsetting) |  |  |  |  | ログの出力設定<br>APIリクエスト・レスポンスログの出力先となる GS2-Log のネームスペースを指定します。クエストの開始・クリア・失敗イベントの追跡に使用されます。 |
| 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>"none",<br>"gs2_script",<br>"aws"<br>}<br> |  |  | "none" |  | 非同期スクリプトの実行方法<br>非同期実行で使用するスクリプトの種類を指定します。<br>「非同期実行のスクリプトを使用しない(none)」「GS2-Scriptを使用する(gs2_script)」「Amazon EventBridgeを使用する(aws)」が選択できます。"none": なし / "gs2_script": GS2-Script / "aws": Amazon EventBridge /  |
| doneTriggerScriptId | string | {doneTriggerTargetType} == "gs2_script" |  |  |  ~ 1024文字 | 非同期実行する GS2-Script スクリプトGRN<br>「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。<br>※ doneTriggerTargetType が "gs2_script" であれば 有効 |
| doneTriggerQueueNamespaceId | string | {doneTriggerTargetType} == "gs2_script" |  |  |  ~ 1024文字 | 非同期実行スクリプトを実行する GS2-JobQueue ネームスペースGRN<br>非同期実行スクリプトを直接実行するのではなく、GS2-JobQueue を経由する場合は GS2-JobQueue のネームスペースGRN を指定します。<br>GS2-JobQueue を利用する理由は多くはありませんので、特に理由がなければ指定する必要はありません。<br>※ doneTriggerTargetType が "gs2_script" であれば 有効 |

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


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



---

### LogSetting

ログの出力設定<br>

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


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

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


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



---

### GitHubCheckoutSetting

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


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string |  | ✓ |  |  ~ 1024文字 | GitHub APIキーのGRN |
| repositoryName | string |  | ✓ |  |  ~ 1024文字 | リポジトリ名 |
| sourcePath | string |  | ✓ |  |  ~ 1024文字 | マスターデータ（JSON）ファイルのパス |
| referenceType | 文字列列挙型<br>enum {<br>"commit_hash",<br>"branch",<br>"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" であれば 必須 |

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



---

### Progress

クエスト進行状況<br>

クエストの開始時に作成され、終了時に削除されます。<br>

インゲームの途中でアプリを終了した際にはこのデータが残った状態となり<br>
エンティティが保持する進行中のクエスト情報からゲームをリジュームすることが可能です。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| progressId | string |  | ※ |  |  ~ 1024文字 | クエスト進行状況GRN<br>※ サーバーが自動で設定 |
| userId | string |  | ✓ |  |  ~ 128文字 | ユーザーID |
| transactionId | string |  | ✓ | UUID |  ~ 36文字 | トランザクションID<br>クエストトランザクションの一意の識別子です。クエスト進行状況と報酬配布を管理するトランザクションを紐付けるために使用されます。 |
| questModelId | string |  | ✓ |  |  ~ 1024文字 | クエストモデルGRN<br>現在進行中のクエストモデルのGRNです。ユーザーがプレイ中のクエストを識別し、クエスト途中でアプリを終了した場合のゲームリジュームを可能にします。 |
| randomSeed | long |  | ✓ |  | 0 ~ 9223372036854775805 | 乱数シード<br>クエスト開始時に割り当てられる乱数シードです。このクエスト試行で選択されるコンテンツバリエーション（報酬セット）の決定に使用され、再現可能な結果を保証します。 |
| rewards | [List&lt;Reward&gt;](#reward) |  |  | [] | 0 ~ 1000 items | クリア報酬リスト<br>クエストクリア時に付与される報酬のリストです。乱数シードで選択されたコンテンツバリエーションに基づき、クエスト開始時に決定されます。 |
| failedRewards | [List&lt;Reward&gt;](#reward) |  |  | [] | 0 ~ 1000 items | 失敗時報酬リスト<br>クエスト失敗時に付与される報酬のリストです。クエスト開始時に決定され、失敗時の慰労報酬やコストの一部返還として提供されます。 |
| metadata | string |  |  |  |  ~ 256文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeProgressesByUserId - クエスト進行状況の一覧を取得
createProgressByUserId - ユーザーIDを指定してクエストの進行状況を作成
getProgress - クエスト進行状況を取得
getProgressByUserId - ユーザーIDを指定してクエスト進行状況を取得
end - クエストを完了
endByUserId - ユーザーIDを指定してクエストを完了
deleteProgress - クエスト進行状況を削除
deleteProgressByUserId - ユーザーIDを指定してクエスト進行状況を削除



---

### CompletedQuestList

クリア済みクエストリスト<br>

クエストグループ内でユーザーがクリアしたクエストを追跡します。前提クエストのクリア判定や初回クリアボーナスの判定に使用されます。各クエスト名はクリア回数に関わらず一度だけ記録されます。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| completedQuestListId | string |  | ※ |  |  ~ 1024文字 | クリア済みクエストリストGRN<br>※ サーバーが自動で設定 |
| userId | string |  | ✓ |  |  ~ 128文字 | ユーザーID |
| questGroupName | string |  | ✓ |  |  ~ 128文字 | クエストグループモデル名<br>このクリア済みクエストリストが属するクエストグループの名前です。ユーザーごと・クエストグループごとに1つの CompletedQuestList が存在します。 |
| completeQuestNames | List&lt;string&gt; |  |  | [] | 0 ~ 1000 items | クリア済みクエスト名リスト<br>このクエストグループ内でユーザーがクリアしたクエスト名のリストです。初回クリア時にクエスト名が追加され、重複は排除されます。前提クエスト条件の評価や初回クリアボーナスの判定に使用されます。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeCompletedQuestLists - クリア済みクエストリストの一覧を取得
describeCompletedQuestListsByUserId - ユーザーIDを指定してクリア済みクエストリストの一覧を取得
getCompletedQuestList - クリア済みのクエストリストを取得
getCompletedQuestListByUserId - ユーザーIDを指定してクリア済みクエストリストを取得
deleteCompletedQuestListByUserId - ユーザーIDを指定してクリア済みクエストリストを削除



---

### QuestGroupModel

クエストグループモデル<br>

クエストグループは複数のクエストをグルーピングするためのエンティティで、クエストの進行はグループ内で同時に1つしか実行できません。<br>
つまり、並列でクエストを進行できるようにする必要がある場合はグループを分ける必要があります。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| questGroupModelId | string |  | ※ |  |  ~ 1024文字 | クエストグループモデルGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | クエストグループモデル名<br>クエストグループモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string |  |  |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| quests | [List&lt;QuestModel&gt;](#questmodel) |  |  | [] | 0 ~ 1000 items | グループに属するクエスト<br>このクエストグループに属するクエストモデルのリストです。グループ内では同時に1つのクエストのみ進行できます。 |
| challengePeriodEventId | string |  |  |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このグループ内のクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。 |

**関連するメソッド:**
getProgress - クエスト進行状況を取得
getProgressByUserId - ユーザーIDを指定してクエスト進行状況を取得
describeQuestGroupModels - クエストグループモデルの一覧を取得
getQuestGroupModel - クエストグループモデルを取得



---

### QuestModel

クエストモデル<br>

クエストモデルはインゲームの開始に必要な対価とクリアしたときに得られる報酬を保持するエンティティです。<br>

クリアしたときに得られる報酬は複数のバリエーションを用意でき、クエスト開始時に抽選することができます。<br>
例えば、クエスト自体は同じでも、レアモンスターの出現有無によって2種類のコンテンツバリエーションを作成できます。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| questModelId | string |  | ※ |  |  ~ 1024文字 | クエストモデルGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | クエストモデル名<br>クエストモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string |  |  |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| contents | [List&lt;Contents&gt;](#contents) |  |  | [] | 1 ~ 10 items | クエストの内容<br>このクエストのコンテンツバリエーションのリストです。クエスト開始時に重み付き抽選で1つのバリエーションが選択されます。各バリエーションに異なるクリア報酬を定義でき、同じクエストでも異なる結果（例：レアモンスターの出現）を実現できます。 |
| challengePeriodEventId | string |  |  |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。この設定はクエストグループの挑戦可能期間より優先されます。 |
| firstCompleteAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  |  | [] | 0 ~ 10 items | 初回クリア報酬入手アクションリスト<br>このクエストの初回クリア時にのみ実行される入手アクションのリストです。通常のクリア報酬に加えて付与されるボーナス報酬で、初回クリアボーナスの実現に使用します。 |
| verifyActions | [List&lt;VerifyAction&gt;](#verifyaction) |  |  | [] | 0 ~ 10 items | 検証アクションリスト<br>このクエストを開始するための前提条件となる検証アクションのリストです。すべての検証アクションが成功しないとクエストを開始できません。レベル確認やアイテム所持などの要件の強制に使用します。 |
| consumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) |  |  | [] | 0 ~ 10 items | 消費アクションリスト<br>このクエストの開始コストとして実行される消費アクションです。スタミナや通貨などのコストがクエスト開始時に消費されます。 |
| failedAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  |  | [] | 0 ~ 100 items | 失敗時入手アクションリスト<br>クエスト失敗時に実行される入手アクションです。失敗時の慰労報酬やクエスト参加コストの一部返還などに使用します。 |
| premiseQuestNames | List&lt;string&gt; |  |  | [] | 0 ~ 10 items | 前提クエスト名リスト<br>このクエストに挑戦する前にクリアが必要な同グループ内のクエスト名のリストです。連続するクエストチェーンや分岐するクエストパスの作成に使用します。 |

**関連するメソッド:**
getProgress - クエスト進行状況を取得
getProgressByUserId - ユーザーIDを指定してクエスト進行状況を取得
describeQuestModels - クエストモデルの一覧を取得
getQuestModel - クエストモデルを取得


**関連するモデル:**
QuestGroupModel - クエストグループモデル



---

### Contents

コンテンツ<br>

クエストコンテンツの1つのバリエーションを表します。各クエストは異なる報酬を持つ複数のコンテンツバリエーションを持つことができ、クエスト開始時に重み付き抽選で1つが選択されます。メタデータはユーザーIDやコンフィグ値によるテンプレート変数の置換をサポートします。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| metadata | string |  |  |  |  ~ 256文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| completeAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  |  | [] | 0 ~ 10 items | クリア報酬入手アクション<br>このコンテンツバリエーションでクエストをクリアした際に実行される入手アクションです。プレイヤーがクエストクリア時に受け取る実際の報酬を定義します。 |
| weight | int |  |  | 1 | 1 ~ 2147483646 | 抽選の重み<br>クエスト開始時のコンテンツバリエーション抽選で使用される相対的な重みです。値が大きいほどこのバリエーションが選択される確率が高くなります。例えば、重み9のバリエーションは重み1のバリエーションの9倍選択されやすくなります。 |

**関連するモデル:**
QuestModel - クエストモデル
QuestModelMaster - クエストモデルマスター



---

### Reward

報酬<br>

クエスト開始時に決定される個々の報酬アイテムを表します。実行する入手アクション、対象リソース、付与する数量を含みます。Progress エンティティに保存され、クエストのクリアまたは失敗時の報酬配布に使用されます。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型<br>enum {<br>}<br> |  | ✓ |  |  | 入手アクションで実行するアクションの種類 |
| request | string |  | ✓ |  |  ~ 5242880文字 | リクエスト<br>入手アクション実行時に使用されるリクエストパラメータのJSON文字列です。対象ネームスペース、リソース名、数量など、報酬の具体的な詳細を含みます。 |
| itemId | string |  | ✓ |  |  ~ 1024文字 | アイテムID<br>報酬として入手するリソースのGRNです。プレイヤーに付与されるアイテム、通貨、その他のリソースを特定します。 |
| value | int |  | ✓ |  | 0 ~ 2147483646 | 数量<br>報酬として付与するリソースの数量です。ゲームロジックに基づいて動的に調整することが可能です。 |

**関連するモデル:**
Progress - クエスト進行状況



---

### AcquireAction

入手アクション


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

**関連するモデル:**
QuestModel - クエストモデル
Contents - コンテンツ
QuestModelMaster - クエストモデルマスター



---

### ConsumeAction

消費アクション


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

**関連するモデル:**
QuestModel - クエストモデル
QuestModelMaster - クエストモデルマスター



---

### VerifyAction

検証アクション


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

**関連するモデル:**
QuestModel - クエストモデル
QuestModelMaster - クエストモデルマスター



---

### Config

コンフィグ設定<br>

トランザクションの変数に適用する設定値


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| key | string |  | ✓ |  |  ~ 64文字 | 名前 |
| value | string |  |  |  |  ~ 51200文字 | 値 |


---

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

**関連するメソッド:**
start - クエストを開始
startByUserId - ユーザーIDを指定してクエストを開始
end - クエストを完了
endByUserId - ユーザーIDを指定してクエストを完了



---

### CurrentQuestMaster

現在アクティブなクエストモデルのマスターデータ<br>

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

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


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

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



---

### QuestGroupModelMaster

クエストグループモデルマスター<br>

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

クエストグループは複数のクエストをグルーピングするためのエンティティで、クエストの進行はグループ内で同時に1つしか実行できません。<br>
つまり、並列でクエストを進行できるようにする必要がある場合はグループを分ける必要があります。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| questGroupModelId | string |  | ※ |  |  ~ 1024文字 | クエストグループモデルマスターGRN<br>※ サーバーが自動で設定 |
| name | string |  | ✓ |  |  ~ 128文字 | クエストグループモデル名<br>クエストグループモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  |  |  |  ~ 1024文字 | 説明文 |
| metadata | string |  |  |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| challengePeriodEventId | string |  |  |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このグループ内のクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeQuestGroupModelMasters - クエストグループモデルマスターの一覧を取得
createQuestGroupModelMaster - クエストグループモデルマスターを新規作成
getQuestGroupModelMaster - クエストグループモデルマスターを取得
updateQuestGroupModelMaster - クエストグループモデルマスターを更新
deleteQuestGroupModelMaster - クエストグループモデルマスターを削除



---

### QuestModelMaster

クエストモデルマスター<br>

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

クエストモデルはインゲームの開始に必要な費用とクリアしたときに得られる報酬を保持するエンティティです。<br>

クリアしたときに得られる報酬は複数のバリエーションを用意でき、クエスト開始時に抽選することができます。<br>
例えば、クエスト自体は同じでも、レアモンスターの出現有無によって2種類のコンテンツバリエーションを作成できます。


|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| questModelId | string |  | ※ |  |  ~ 1024文字 | クエストモデルマスターGRN<br>※ サーバーが自動で設定 |
| questGroupName | string |  | ✓ |  |  ~ 128文字 | クエストグループモデル名 |
| name | string |  | ✓ |  |  ~ 128文字 | クエストモデル名<br>クエストモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  |  |  |  ~ 1024文字 | 説明文 |
| metadata | string |  |  |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| contents | [List&lt;Contents&gt;](#contents) |  | ✓ |  | 1 ~ 10 items | クエストの内容<br>このクエストのコンテンツバリエーションのリストです。クエスト開始時に重み付き抽選で1つのバリエーションが選択されます。各バリエーションに異なるクリア報酬を定義でき、同じクエストでも異なる結果（例：レアモンスターの出現）を実現できます。 |
| challengePeriodEventId | string |  |  |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。この設定はクエストグループの挑戦可能期間より優先されます。 |
| firstCompleteAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  |  | [] | 0 ~ 10 items | 初回クリア報酬入手アクションリスト<br>このクエストの初回クリア時にのみ実行される入手アクションのリストです。通常のクリア報酬に加えて付与されるボーナス報酬で、初回クリアボーナスの実現に使用します。 |
| verifyActions | [List&lt;VerifyAction&gt;](#verifyaction) |  |  | [] | 0 ~ 10 items | 検証アクションリスト<br>このクエストを開始するための前提条件となる検証アクションのリストです。すべての検証アクションが成功しないとクエストを開始できません。レベル確認やアイテム所持などの要件の強制に使用します。 |
| consumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) |  |  | [] | 0 ~ 10 items | 消費アクションリスト<br>このクエストの開始コストとして実行される消費アクションです。スタミナや通貨などのコストがクエスト開始時に消費されます。 |
| failedAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  |  | [] | 0 ~ 100 items | 失敗時入手アクションリスト<br>クエスト失敗時に実行される入手アクションです。失敗時の慰労報酬やクエスト参加コストの一部返還などに使用します。 |
| premiseQuestNames | List&lt;string&gt; |  |  | [] | 0 ~ 10 items | 前提クエスト名リスト<br>このクエストに挑戦する前にクリアが必要な同グループ内のクエスト名のリストです。連続するクエストチェーンや分岐するクエストパスの作成に使用します。 |
| createdAt | long |  | ※ | 現在時刻 |  | 作成日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| updatedAt | long |  | ※ | 現在時刻 |  | 最終更新日時<br>UNIX 時間・ミリ秒<br>※ サーバーが自動で設定 |
| revision | long |  |  | 0 | 0 ~ 9223372036854775805 | リビジョン |

**関連するメソッド:**
describeQuestModelMasters - クエストモデルマスターの一覧を取得
createQuestModelMaster - クエストモデルマスターを新規作成
getQuestModelMaster - クエストモデルマスターを取得
updateQuestModelMaster - クエストモデルマスターを更新
deleteQuestModelMaster - クエストモデルマスターを削除



---
## メソッド

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

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

$session->open();

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

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

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

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

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

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

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

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

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>クエスト報酬の付与時のトランザクションの処理方法を制御する設定です。 |
| startQuestScript | [ScriptSetting](#scriptsetting) |  | |  |  | クエスト開始したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`startQuest`](../script/#startquest) |
| completeQuestScript | [ScriptSetting](#scriptsetting) |  | |  |  | クエストクリアしたときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`completeQuest`](../script/#completequest) |
| failedQuestScript | [ScriptSetting](#scriptsetting) |  | |  |  | クエスト失敗したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`failedQuest`](../script/#failedquest) |
| logSetting | [LogSetting](#logsetting) |  | |  |  | ログの出力設定<br>APIリクエスト・レスポンスログの出力先となる GS2-Log のネームスペースを指定します。クエストの開始・クリア・失敗イベントの追跡に使用されます。 |

#### Result

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

#### 実装例




**Go**
```go

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

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

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

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

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

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

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

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

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

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

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

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",
    },
    startQuestScript=nil,
    completeQuestScript=nil,
    failedQuestScript=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 | ネームスペースの状態<br>"ACTIVE": 有効 / "DELETED": 削除済み /  |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &quest.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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetNamespaceStatusRequest;

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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>クエスト報酬の付与時のトランザクションの処理方法を制御する設定です。 |
| startQuestScript | [ScriptSetting](#scriptsetting) |  | |  |  | クエスト開始したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`startQuest`](../script/#startquest) |
| completeQuestScript | [ScriptSetting](#scriptsetting) |  | |  |  | クエストクリアしたときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`completeQuest`](../script/#completequest) |
| failedQuestScript | [ScriptSetting](#scriptsetting) |  | |  |  | クエスト失敗したときに実行するスクリプトの設定<br>Script トリガーリファレンス - [`failedQuest`](../script/#failedquest) |
| logSetting | [LogSetting](#logsetting) |  | |  |  | ログの出力設定<br>APIリクエスト・レスポンスログの出力先となる GS2-Log のネームスペースを指定します。クエストの開始・クリア・失敗イベントの追跡に使用されます。 |

#### Result

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

#### 実装例




**Go**
```go

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

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

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

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

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

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

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

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

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

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

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

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",
    },
    startQuestScript=nil,
    completeQuestScript=nil,
    failedQuestScript=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/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &quest.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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DeleteNamespaceRequest;

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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

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

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

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

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

$session->open();

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

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

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

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

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

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

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

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

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

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

$session->open();

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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

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

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

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

$session->open();

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

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

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

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

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

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

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

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

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;

```



---

### describeProgressesByUserId

クエスト進行状況の一覧を取得<br>

指定したユーザーのクエスト進行状況を取得します。ユーザーはクエストグループごとに同時に1つのクエスト進行状況のみ保持できます。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;Progress&gt;](#progress) | クエスト進行状況のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DescribeProgressesByUserId(
    &quest.DescribeProgressesByUserIdRequest {
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DescribeProgressesByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->describeProgressesByUserId(
        (new DescribeProgressesByUserIdRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DescribeProgressesByUserIdRequest;
import io.gs2.quest.result.DescribeProgressesByUserIdResult;

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

try {
    DescribeProgressesByUserIdResult result = client.describeProgressesByUserId(
        new DescribeProgressesByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<Progress> 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DescribeProgressesByUserIdResult> asyncResult = null;
yield return client.DescribeProgressesByUserId(
    new Gs2.Gs2Quest.Request.DescribeProgressesByUserIdRequest()
        .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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.describeProgressesByUserId(
        new Gs2Quest.DescribeProgressesByUserIdRequest()
            .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 quest

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

try:
    result = client.describe_progresses_by_user_id(
        quest.DescribeProgressesByUserIdRequest()
            .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('quest')

api_result = client.describe_progresses_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('quest')

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

```



---

### createProgressByUserId

ユーザーIDを指定してクエストの進行状況を作成<br>

クエストモデルを参照し、クエストコンテンツの抽選を行ってクエストを開始します。すでに進行中のクエストがある場合、force フラグが設定されていなければエラーを返します。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| questModelId | string |  | ✓|  |  ~ 1024文字 | 開始するクエストモデルGRN |
| force | bool |  | | false |  | すでに開始しているクエストがある場合にそれを破棄して開始するか |
| config | [List&lt;Config&gt;](#config) |  | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Progress](#progress) | クエスト進行状況 |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.CreateProgressByUserId(
    &quest.CreateProgressByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        QuestModelId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1"),
        Force: nil,
        Config: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\CreateProgressByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->createProgressByUserId(
        (new CreateProgressByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withQuestModelId("grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1")
            ->withForce(null)
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.CreateProgressByUserIdRequest;
import io.gs2.quest.result.CreateProgressByUserIdResult;

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

try {
    CreateProgressByUserIdResult result = client.createProgressByUserId(
        new CreateProgressByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withQuestModelId("grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1")
            .withForce(null)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    Progress 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.CreateProgressByUserIdResult> asyncResult = null;
yield return client.CreateProgressByUserId(
    new Gs2.Gs2Quest.Request.CreateProgressByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithQuestModelId("grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1")
        .WithForce(null)
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.createProgressByUserId(
        new Gs2Quest.CreateProgressByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withQuestModelId("grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1")
            .withForce(null)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.create_progress_by_user_id(
        quest.CreateProgressByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_quest_model_id('grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1')
            .with_force(None)
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.create_progress_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    questModelId="grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1",
    force=nil,
    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;

```

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

client = gs2('quest')

api_result_handler = client.create_progress_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    questModelId="grn:gs2:ap-northeast-1:YourOwnerId:quest:namespace-0001:group:main:quest:1-1",
    force=nil,
    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;

```



---

### getProgress

クエスト進行状況を取得<br>

現在のクエスト進行状況を、関連するクエストグループモデルおよびクエストモデルとともに取得します。クエストの再開や表示に必要なすべての情報を提供します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Progress](#progress) | クエスト進行状況 |
| questGroup | [QuestGroupModel](#questgroupmodel) | クエストグループモデル |
| quest | [QuestModel](#questmodel) | クエストモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetProgress(
    &quest.GetProgressRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
questGroup := result.QuestGroup
quest := result.Quest

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetProgressRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getProgress(
        (new GetProgressRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
    );
    $item = $result->getItem();
    $questGroup = $result->getQuestGroup();
    $quest = $result->getQuest();
} 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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetProgressRequest;
import io.gs2.quest.result.GetProgressResult;

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

try {
    GetProgressResult result = client.getProgress(
        new GetProgressRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    Progress item = result.getItem();
    QuestGroupModel questGroup = result.getQuestGroup();
    QuestModel quest = result.getQuest();
} 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetProgressResult> asyncResult = null;
yield return client.GetProgress(
    new Gs2.Gs2Quest.Request.GetProgressRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var questGroup = result.QuestGroup;
var quest = result.Quest;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getProgress(
        new Gs2Quest.GetProgressRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    const item = result.getItem();
    const questGroup = result.getQuestGroup();
    const quest = result.getQuest();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_progress(
        quest.GetProgressRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
    )
    item = result.item
    quest_group = result.quest_group
    quest = result.quest
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

result = api_result.result
item = result.item;
questGroup = result.questGroup;
quest = result.quest;

```

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

client = gs2('quest')

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

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

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

result = api_result.result
item = result.item;
questGroup = result.questGroup;
quest = result.quest;

```



---

### getProgressByUserId

ユーザーIDを指定してクエスト進行状況を取得<br>

指定したユーザーの現在のクエスト進行状況を、関連するクエストグループモデルおよびクエストモデルとともに取得します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Progress](#progress) | クエスト進行状況 |
| questGroup | [QuestGroupModel](#questgroupmodel) | クエストグループモデル |
| quest | [QuestModel](#questmodel) | クエストモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetProgressByUserId(
    &quest.GetProgressByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
questGroup := result.QuestGroup
quest := result.Quest

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetProgressByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getProgressByUserId(
        (new GetProgressByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $questGroup = $result->getQuestGroup();
    $quest = $result->getQuest();
} 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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetProgressByUserIdRequest;
import io.gs2.quest.result.GetProgressByUserIdResult;

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

try {
    GetProgressByUserIdResult result = client.getProgressByUserId(
        new GetProgressByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    Progress item = result.getItem();
    QuestGroupModel questGroup = result.getQuestGroup();
    QuestModel quest = result.getQuest();
} 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetProgressByUserIdResult> asyncResult = null;
yield return client.GetProgressByUserId(
    new Gs2.Gs2Quest.Request.GetProgressByUserIdRequest()
        .WithNamespaceName("namespace-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 questGroup = result.QuestGroup;
var quest = result.Quest;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getProgressByUserId(
        new Gs2Quest.GetProgressByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    const questGroup = result.getQuestGroup();
    const quest = result.getQuest();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_progress_by_user_id(
        quest.GetProgressByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
    quest_group = result.quest_group
    quest = result.quest
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

result = api_result.result
item = result.item;
questGroup = result.questGroup;
quest = result.quest;

```

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

client = gs2('quest')

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

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

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

result = api_result.result
item = result.item;
questGroup = result.questGroup;
quest = result.quest;

```



---

### start

クエストを開始<br>

同一カテゴリ内でゲームプレイヤーは同時に1つのクエストを実行できます。<br>
すでに同一カテゴリ内で実行中のクエストがある場合、このAPIはエラーを返します。<br>
進行中のクエストを取得するAPIを呼び出すことで、クエストを再開するために必要な情報を得ることができます。<br>
強制的にクエストを開始するには force パラメータに true を指定することで強制的にクエストを開始できます。<br>

クエストが正常に開始できた場合、Progress オブジェクトを応答します。<br>
Progress オブジェクトはクエストを実行するために必要ないくつかの情報を応答します。<br>

transactionId は実行中のクエスト固有のIDです。<br>
クエストの完了報告にはこのIDを指定する必要があります。<br>

randomSeed はクエストの内容を決定するために使用できる乱数シードです。<br>
クエストを開始するたびに異なる乱数が払い出されますので、この値をシード値としてゲームを進行させることで<br>
クエスト中にアプリケーションを強制終了したとしても同一条件で再開することができます。<br>

rewards にはこのクエストにおいて入手可能な報酬とその数量の"最大値"が得られます。<br>
クエストの完了報告にも rewards を渡すことができ、そこでクエスト中に実際に入手したアイテムの数量を指定します。<br>
詳細はクエストの完了報告APIのドキュメントを参照してください。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名 |
| questName | string |  | ✓|  |  ~ 128文字 | クエストモデル名 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |
| force | bool |  | | false |  | すでに開始しているクエストがある場合にそれを破棄して開始するか |
| config | [List&lt;Config&gt;](#config) |  | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| 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/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.Start(
    &quest.StartRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("group-0001"),
        QuestName: pointy.String("quest-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        Force: nil,
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\StartRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->start(
        (new StartRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("group-0001")
            ->withQuestName("quest-0001")
            ->withAccessToken("accessToken-0001")
            ->withForce(null)
            ->withConfig(null)
    );
    $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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.StartRequest;
import io.gs2.quest.result.StartResult;

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

try {
    StartResult result = client.start(
        new StartRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("group-0001")
            .withQuestName("quest-0001")
            .withAccessToken("accessToken-0001")
            .withForce(null)
            .withConfig(null)
    );
    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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.StartResult> asyncResult = null;
yield return client.Start(
    new Gs2.Gs2Quest.Request.StartRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("group-0001")
        .WithQuestName("quest-0001")
        .WithAccessToken("accessToken-0001")
        .WithForce(null)
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.start(
        new Gs2Quest.StartRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("group-0001")
            .withQuestName("quest-0001")
            .withAccessToken("accessToken-0001")
            .withForce(null)
            .withConfig(null)
    );
    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 quest

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

try:
    result = client.start(
        quest.StartRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('group-0001')
            .with_quest_name('quest-0001')
            .with_access_token('accessToken-0001')
            .with_force(None)
            .with_config(None)
    )
    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('quest')

api_result = client.start({
    namespaceName="namespace-0001",
    questGroupName="group-0001",
    questName="quest-0001",
    accessToken="accessToken-0001",
    force=nil,
    config=nil,
})

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

result = api_result.result
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('quest')

api_result_handler = client.start_async({
    namespaceName="namespace-0001",
    questGroupName="group-0001",
    questName="quest-0001",
    accessToken="accessToken-0001",
    force=nil,
    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
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```



---

### startByUserId

ユーザーIDを指定してクエストを開始<br>

同一カテゴリ内でゲームプレイヤーは同時に1つのクエストを実行できます。<br>
すでに同一カテゴリ内で実行中のクエストがある場合、このAPIはエラーを返します。<br>
進行中のクエストを取得するAPIを呼び出すことで、クエストを再開するために必要な情報を得ることができます。<br>
強制的にクエストを開始するには force パラメータに true を指定することで強制的にクエストを開始できます。<br>

クエストが正常に開始できた場合、Progress オブジェクトを応答します。<br>
Progress オブジェクトはクエストを実行するために必要ないくつかの情報を応答します。<br>

transactionId は実行中のクエスト固有のIDです。<br>
クエストの完了報告にはこのIDを指定する必要があります。<br>

randomSeed はクエストの内容を決定するために使用できる乱数シードです。<br>
クエストを開®®始するたびに異なる乱数が払い出されますので、この値をシード値としてゲームを進行させることで<br>
クエスト中にアプリケーションを強制終了したとしても同一条件で再開することができます。<br>

rewards にはこのクエストにおいて入手可能な報酬とその数量の"最大値"が得られます。<br>
クエストの完了報告にも rewards を渡すことができ、そこでクエスト中に実際に入手したアイテムの数量を指定します。<br>
詳細はクエストの完了報告APIのドキュメントを参照してください。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名 |
| questName | string |  | ✓|  |  ~ 128文字 | クエストモデル名 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| force | bool |  | | false |  | すでに開始しているクエストがある場合にそれを破棄して開始するか |
| config | [List&lt;Config&gt;](#config) |  | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| 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/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.StartByUserId(
    &quest.StartByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("group-0001"),
        QuestName: pointy.String("quest-0001"),
        UserId: pointy.String("user-0001"),
        Force: nil,
        Config: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\StartByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->startByUserId(
        (new StartByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("group-0001")
            ->withQuestName("quest-0001")
            ->withUserId("user-0001")
            ->withForce(null)
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.StartByUserIdRequest;
import io.gs2.quest.result.StartByUserIdResult;

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

try {
    StartByUserIdResult result = client.startByUserId(
        new StartByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("group-0001")
            .withQuestName("quest-0001")
            .withUserId("user-0001")
            .withForce(null)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.StartByUserIdResult> asyncResult = null;
yield return client.StartByUserId(
    new Gs2.Gs2Quest.Request.StartByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("group-0001")
        .WithQuestName("quest-0001")
        .WithUserId("user-0001")
        .WithForce(null)
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.startByUserId(
        new Gs2Quest.StartByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("group-0001")
            .withQuestName("quest-0001")
            .withUserId("user-0001")
            .withForce(null)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    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 quest

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

try:
    result = client.start_by_user_id(
        quest.StartByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('group-0001')
            .with_quest_name('quest-0001')
            .with_user_id('user-0001')
            .with_force(None)
            .with_config(None)
            .with_time_offset_token(None)
    )
    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('quest')

api_result = client.start_by_user_id({
    namespaceName="namespace-0001",
    questGroupName="group-0001",
    questName="quest-0001",
    userId="user-0001",
    force=nil,
    config=nil,
    timeOffsetToken=nil,
})

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

result = api_result.result
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('quest')

api_result_handler = client.start_by_user_id_async({
    namespaceName="namespace-0001",
    questGroupName="group-0001",
    questName="quest-0001",
    userId="user-0001",
    force=nil,
    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
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```



---

### end

クエストを完了<br>

開始時に受け取ったクエストにおいて入手可能な報酬とその数量の"最大値"のうち、クエスト内で実際に入手した報酬を rewards で報告します。<br>
isComplete にはクエストをクリアできたかを報告します。クエストに失敗した場合、rewards の値は無視してクエストに設定された失敗した場合の報酬が付与されます。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Progress](#progress) | クエスト進行状況 |
| 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/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.End(
    &quest.EndRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-0001"),
        Rewards: []quest.Reward{},
        IsComplete: pointy.Bool(true),
        Config: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\EndRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->end(
        (new EndRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-0001")
            ->withRewards([])
            ->withIsComplete(true)
            ->withConfig(null)
    );
    $item = $result->getItem();
    $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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.EndRequest;
import io.gs2.quest.result.EndResult;

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

try {
    EndResult result = client.end(
        new EndRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withRewards(new ArrayList<Reward>())
            .withIsComplete(true)
            .withConfig(null)
    );
    Progress item = result.getItem();
    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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.EndResult> asyncResult = null;
yield return client.End(
    new Gs2.Gs2Quest.Request.EndRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-0001")
        .WithRewards(new Gs2.Gs2Quest.Model.Reward[] {})
        .WithIsComplete(true)
        .WithConfig(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.end(
        new Gs2Quest.EndRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withRewards([])
            .withIsComplete(true)
            .withConfig(null)
    );
    const item = result.getItem();
    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 quest

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

try:
    result = client.end(
        quest.EndRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
            .with_rewards([])
            .with_is_complete(True)
            .with_config(None)
    )
    item = result.item
    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('quest')

api_result = client.end({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    rewards={},
    isComplete=true,
    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;
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('quest')

api_result_handler = client.end_async({
    namespaceName="namespace-0001",
    accessToken="accessToken-0001",
    rewards={},
    isComplete=true,
    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;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```



---

### endByUserId

ユーザーIDを指定してクエストを完了<br>

開始時に受け取ったクエストにおいて入手可能な報酬とその数量の"最大値"のうち、クエスト内で実際に入手した報酬を rewards で報告します。<br>
isComplete にはクエストをクリアできたかを報告します。クエストに失敗した場合、rewards の値は無視してクエストに設定された失敗した場合の報酬が付与されます。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Progress](#progress) | クエスト進行状況 |
| 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/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.EndByUserId(
    &quest.EndByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        Rewards: []quest.Reward{},
        IsComplete: pointy.Bool(true),
        Config: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\EndByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->endByUserId(
        (new EndByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withRewards([])
            ->withIsComplete(true)
            ->withConfig(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
    $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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.EndByUserIdRequest;
import io.gs2.quest.result.EndByUserIdResult;

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

try {
    EndByUserIdResult result = client.endByUserId(
        new EndByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withRewards(new ArrayList<Reward>())
            .withIsComplete(true)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    Progress item = result.getItem();
    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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.EndByUserIdResult> asyncResult = null;
yield return client.EndByUserId(
    new Gs2.Gs2Quest.Request.EndByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithRewards(new Gs2.Gs2Quest.Model.Reward[] {})
        .WithIsComplete(true)
        .WithConfig(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.endByUserId(
        new Gs2Quest.EndByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withRewards([])
            .withIsComplete(true)
            .withConfig(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
    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 quest

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

try:
    result = client.end_by_user_id(
        quest.EndByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_rewards([])
            .with_is_complete(True)
            .with_config(None)
            .with_time_offset_token(None)
    )
    item = result.item
    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('quest')

api_result = client.end_by_user_id({
    namespaceName="namespace-0001",
    userId="user-0001",
    rewards={},
    isComplete=true,
    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;
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('quest')

api_result_handler = client.end_by_user_id_async({
    namespaceName="namespace-0001",
    userId="user-0001",
    rewards={},
    isComplete=true,
    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;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;

```



---

### deleteProgress

クエスト進行状況を削除<br>

リクエストしたユーザーの現在のクエスト進行状況を削除します。進行中のクエストをキャンセルし、新しいクエストを開始できるようにします。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Progress](#progress) | クエスト進行状況 |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DeleteProgress(
    &quest.DeleteProgressRequest {
        NamespaceName: pointy.String("namespace-0001"),
        AccessToken: pointy.String("accessToken-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DeleteProgressRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->deleteProgress(
        (new DeleteProgressRequest())
            ->withNamespaceName("namespace-0001")
            ->withAccessToken("accessToken-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DeleteProgressRequest;
import io.gs2.quest.result.DeleteProgressResult;

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

try {
    DeleteProgressResult result = client.deleteProgress(
        new DeleteProgressRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    Progress 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DeleteProgressResult> asyncResult = null;
yield return client.DeleteProgress(
    new Gs2.Gs2Quest.Request.DeleteProgressRequest()
        .WithNamespaceName("namespace-0001")
        .WithAccessToken("accessToken-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.deleteProgress(
        new Gs2Quest.DeleteProgressRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.delete_progress(
        quest.DeleteProgressRequest()
            .with_namespace_name('namespace-0001')
            .with_access_token('accessToken-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

result = api_result.result
item = result.item;

```

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

client = gs2('quest')

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

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

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

result = api_result.result
item = result.item;

```



---

### deleteProgressByUserId

ユーザーIDを指定してクエスト進行状況を削除<br>

指定したユーザーの現在のクエスト進行状況を削除します。進行中のクエストをキャンセルし、新しいクエストを開始できるようにします。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [Progress](#progress) | クエスト進行状況 |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DeleteProgressByUserId(
    &quest.DeleteProgressByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DeleteProgressByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->deleteProgressByUserId(
        (new DeleteProgressByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DeleteProgressByUserIdRequest;
import io.gs2.quest.result.DeleteProgressByUserIdResult;

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

try {
    DeleteProgressByUserIdResult result = client.deleteProgressByUserId(
        new DeleteProgressByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    Progress 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DeleteProgressByUserIdResult> asyncResult = null;
yield return client.DeleteProgressByUserId(
    new Gs2.Gs2Quest.Request.DeleteProgressByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.deleteProgressByUserId(
        new Gs2Quest.DeleteProgressByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.delete_progress_by_user_id(
        quest.DeleteProgressByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

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

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

result = api_result.result
item = result.item;

```

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

client = gs2('quest')

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

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

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

result = api_result.result
item = result.item;

```



---

### describeCompletedQuestLists

クリア済みクエストリストの一覧を取得<br>

リクエストしたユーザーのクリア済みクエストリストをページネーション付きで取得します。各エントリはクエストグループとその中でクリアしたクエストを表します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;CompletedQuestList&gt;](#completedquestlist) | クリア済みクエストリストの一覧 |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DescribeCompletedQuestLists(
    &quest.DescribeCompletedQuestListsRequest {
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DescribeCompletedQuestListsRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->describeCompletedQuestLists(
        (new DescribeCompletedQuestListsRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DescribeCompletedQuestListsRequest;
import io.gs2.quest.result.DescribeCompletedQuestListsResult;

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

try {
    DescribeCompletedQuestListsResult result = client.describeCompletedQuestLists(
        new DescribeCompletedQuestListsRequest()
            .withNamespaceName("namespace-0001")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<CompletedQuestList> 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DescribeCompletedQuestListsResult> asyncResult = null;
yield return client.DescribeCompletedQuestLists(
    new Gs2.Gs2Quest.Request.DescribeCompletedQuestListsRequest()
        .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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.describeCompletedQuestLists(
        new Gs2Quest.DescribeCompletedQuestListsRequest()
            .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 quest

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

try:
    result = client.describe_completed_quest_lists(
        quest.DescribeCompletedQuestListsRequest()
            .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('quest')

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

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

```



---

### describeCompletedQuestListsByUserId

ユーザー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;CompletedQuestList&gt;](#completedquestlist) | クリア済みクエストリストの一覧 |
| nextPageToken | string | リストの続きを取得するためのページトークン |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DescribeCompletedQuestListsByUserId(
    &quest.DescribeCompletedQuestListsByUserIdRequest {
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DescribeCompletedQuestListsByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->describeCompletedQuestListsByUserId(
        (new DescribeCompletedQuestListsByUserIdRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DescribeCompletedQuestListsByUserIdRequest;
import io.gs2.quest.result.DescribeCompletedQuestListsByUserIdResult;

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

try {
    DescribeCompletedQuestListsByUserIdResult result = client.describeCompletedQuestListsByUserId(
        new DescribeCompletedQuestListsByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<CompletedQuestList> 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DescribeCompletedQuestListsByUserIdResult> asyncResult = null;
yield return client.DescribeCompletedQuestListsByUserId(
    new Gs2.Gs2Quest.Request.DescribeCompletedQuestListsByUserIdRequest()
        .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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.describeCompletedQuestListsByUserId(
        new Gs2Quest.DescribeCompletedQuestListsByUserIdRequest()
            .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 quest

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

try:
    result = client.describe_completed_quest_lists_by_user_id(
        quest.DescribeCompletedQuestListsByUserIdRequest()
            .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('quest')

api_result = client.describe_completed_quest_lists_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('quest')

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

```



---

### getCompletedQuestList

クリア済みのクエストリストを取得<br>

指定したクエストグループのクリア済みクエストリストを取得します。リクエストしたユーザーがグループ内でクリアしたすべてのクエスト名を含みます。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名<br>このクリア済みクエストリストが属するクエストグループの名前です。ユーザーごと・クエストグループごとに1つの CompletedQuestList が存在します。 |
| accessToken | string |  | ✓|  |  ~ 128文字 | アクセストークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CompletedQuestList](#completedquestlist) | クリア済みクエストリスト |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetCompletedQuestList(
    &quest.GetCompletedQuestListRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("main"),
        AccessToken: pointy.String("accessToken-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetCompletedQuestListRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getCompletedQuestList(
        (new GetCompletedQuestListRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("main")
            ->withAccessToken("accessToken-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetCompletedQuestListRequest;
import io.gs2.quest.result.GetCompletedQuestListResult;

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

try {
    GetCompletedQuestListResult result = client.getCompletedQuestList(
        new GetCompletedQuestListRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("main")
            .withAccessToken("accessToken-0001")
    );
    CompletedQuestList 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetCompletedQuestListResult> asyncResult = null;
yield return client.GetCompletedQuestList(
    new Gs2.Gs2Quest.Request.GetCompletedQuestListRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("main")
        .WithAccessToken("accessToken-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getCompletedQuestList(
        new Gs2Quest.GetCompletedQuestListRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("main")
            .withAccessToken("accessToken-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_completed_quest_list(
        quest.GetCompletedQuestListRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('main')
            .with_access_token('accessToken-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.get_completed_quest_list({
    namespaceName="namespace-0001",
    questGroupName="main",
    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;

```

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

client = gs2('quest')

api_result_handler = client.get_completed_quest_list_async({
    namespaceName="namespace-0001",
    questGroupName="main",
    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;

```



---

### getCompletedQuestListByUserId

ユーザーIDを指定してクリア済みクエストリストを取得<br>

指定したクエストグループとユーザーのクリア済みクエストリストを取得します。ユーザーがグループ内でクリアしたすべてのクエスト名を含みます。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名<br>このクリア済みクエストリストが属するクエストグループの名前です。ユーザーごと・クエストグループごとに1つの CompletedQuestList が存在します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CompletedQuestList](#completedquestlist) | クリア済みクエストリスト |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetCompletedQuestListByUserId(
    &quest.GetCompletedQuestListByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("main"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetCompletedQuestListByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getCompletedQuestListByUserId(
        (new GetCompletedQuestListByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("main")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetCompletedQuestListByUserIdRequest;
import io.gs2.quest.result.GetCompletedQuestListByUserIdResult;

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

try {
    GetCompletedQuestListByUserIdResult result = client.getCompletedQuestListByUserId(
        new GetCompletedQuestListByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("main")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    CompletedQuestList 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetCompletedQuestListByUserIdResult> asyncResult = null;
yield return client.GetCompletedQuestListByUserId(
    new Gs2.Gs2Quest.Request.GetCompletedQuestListByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("main")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getCompletedQuestListByUserId(
        new Gs2Quest.GetCompletedQuestListByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("main")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_completed_quest_list_by_user_id(
        quest.GetCompletedQuestListByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('main')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.get_completed_quest_list_by_user_id({
    namespaceName="namespace-0001",
    questGroupName="main",
    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;

```

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

client = gs2('quest')

api_result_handler = client.get_completed_quest_list_by_user_id_async({
    namespaceName="namespace-0001",
    questGroupName="main",
    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;

```



---

### deleteCompletedQuestListByUserId

ユーザーIDを指定してクリア済みクエストリストを削除<br>

指定したクエストグループとユーザーのクリア済みクエストリストを削除します。グループ内のすべてのクエストのクリア状態がリセットされ、初回クリア報酬を再度獲得できるようになります。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名<br>このクリア済みクエストリストが属するクエストグループの名前です。ユーザーごと・クエストグループごとに1つの CompletedQuestList が存在します。 |
| userId | string |  | ✓|  |  ~ 128文字 | ユーザーID |
| timeOffsetToken | string |  | |  |  ~ 1024文字 | タイムオフセットトークン |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CompletedQuestList](#completedquestlist) | クリア済みクエストリスト |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DeleteCompletedQuestListByUserId(
    &quest.DeleteCompletedQuestListByUserIdRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("main"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

```

**PHP**
```php

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DeleteCompletedQuestListByUserIdRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->deleteCompletedQuestListByUserId(
        (new DeleteCompletedQuestListByUserIdRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("main")
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

```

**Java**
```java

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DeleteCompletedQuestListByUserIdRequest;
import io.gs2.quest.result.DeleteCompletedQuestListByUserIdResult;

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

try {
    DeleteCompletedQuestListByUserIdResult result = client.deleteCompletedQuestListByUserId(
        new DeleteCompletedQuestListByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("main")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    CompletedQuestList 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DeleteCompletedQuestListByUserIdResult> asyncResult = null;
yield return client.DeleteCompletedQuestListByUserId(
    new Gs2.Gs2Quest.Request.DeleteCompletedQuestListByUserIdRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("main")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

```

**TypeScript**
```typescript

import Gs2Core from '@/gs2/core';
import * as Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.deleteCompletedQuestListByUserId(
        new Gs2Quest.DeleteCompletedQuestListByUserIdRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("main")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.delete_completed_quest_list_by_user_id(
        quest.DeleteCompletedQuestListByUserIdRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('main')
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.delete_completed_quest_list_by_user_id({
    namespaceName="namespace-0001",
    questGroupName="main",
    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;

```

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

client = gs2('quest')

api_result_handler = client.delete_completed_quest_list_by_user_id_async({
    namespaceName="namespace-0001",
    questGroupName="main",
    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;

```



---

### describeQuestGroupModels

クエストグループモデルの一覧を取得<br>

現在アクティブなクエストグループモデルの一覧を取得します。クエストグループはクエストを整理するカテゴリとして機能し、ユーザーはグループごとに1つのクエストのみ進行できます。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;QuestGroupModel&gt;](#questgroupmodel) | クエストグループモデルのリスト |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DescribeQuestGroupModels(
    &quest.DescribeQuestGroupModelsRequest {
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DescribeQuestGroupModelsRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->describeQuestGroupModels(
        (new DescribeQuestGroupModelsRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DescribeQuestGroupModelsRequest;
import io.gs2.quest.result.DescribeQuestGroupModelsResult;

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

try {
    DescribeQuestGroupModelsResult result = client.describeQuestGroupModels(
        new DescribeQuestGroupModelsRequest()
            .withNamespaceName("namespace-0001")
    );
    List<QuestGroupModel> 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DescribeQuestGroupModelsResult> asyncResult = null;
yield return client.DescribeQuestGroupModels(
    new Gs2.Gs2Quest.Request.DescribeQuestGroupModelsRequest()
        .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 Gs2Quest from '@/gs2/quest';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.describe_quest_group_models(
        quest.DescribeQuestGroupModelsRequest()
            .with_namespace_name('namespace-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.describe_quest_group_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('quest')

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

```



---

### getQuestGroupModel

クエストグループモデルを取得<br>

チャレンジ期間イベント設定と、含まれるクエストモデルの一覧を含む、指定されたクエストグループモデルを取得します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestGroupModel](#questgroupmodel) | クエストグループモデル |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetQuestGroupModel(
    &quest.GetQuestGroupModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetQuestGroupModelRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getQuestGroupModel(
        (new GetQuestGroupModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetQuestGroupModelRequest;
import io.gs2.quest.result.GetQuestGroupModelResult;

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

try {
    GetQuestGroupModelResult result = client.getQuestGroupModel(
        new GetQuestGroupModelRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    QuestGroupModel 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetQuestGroupModelResult> asyncResult = null;
yield return client.GetQuestGroupModel(
    new Gs2.Gs2Quest.Request.GetQuestGroupModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getQuestGroupModel(
        new Gs2Quest.GetQuestGroupModelRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_quest_group_model(
        quest.GetQuestGroupModelRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.get_quest_group_model({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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('quest')

api_result_handler = client.get_quest_group_model_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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;

```



---

### describeQuestModels

クエストモデルの一覧を取得<br>

指定したクエストグループ内の現在アクティブなクエストモデルの一覧を取得します。これらのモデルはクエストのコンテンツ、報酬、条件を定義します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| items | [List&lt;QuestModel&gt;](#questmodel) | クエストモデルのリスト |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DescribeQuestModels(
    &quest.DescribeQuestModelsRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DescribeQuestModelsRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->describeQuestModels(
        (new DescribeQuestModelsRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DescribeQuestModelsRequest;
import io.gs2.quest.result.DescribeQuestModelsResult;

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

try {
    DescribeQuestModelsResult result = client.describeQuestModels(
        new DescribeQuestModelsRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    List<QuestModel> 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DescribeQuestModelsResult> asyncResult = null;
yield return client.DescribeQuestModels(
    new Gs2.Gs2Quest.Request.DescribeQuestModelsRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.describeQuestModels(
        new Gs2Quest.DescribeQuestModelsRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    const items = result.getItems();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.describe_quest_models(
        quest.DescribeQuestModelsRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
    )
    items = result.items
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.describe_quest_models({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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('quest')

api_result_handler = client.describe_quest_models_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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;

```



---

### getQuestModel

クエストモデルを取得<br>

コンテンツ定義、報酬設定、消費アクション、前提クエスト条件を含む、指定されたクエストモデルを取得します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestModel](#questmodel) |  |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetQuestModel(
    &quest.GetQuestModelRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-0001"),
        QuestName: pointy.String("quest-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetQuestModelRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getQuestModel(
        (new GetQuestModelRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-0001")
            ->withQuestName("quest-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetQuestModelRequest;
import io.gs2.quest.result.GetQuestModelResult;

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

try {
    GetQuestModelResult result = client.getQuestModel(
        new GetQuestModelRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
    );
    QuestModel 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetQuestModelResult> asyncResult = null;
yield return client.GetQuestModel(
    new Gs2.Gs2Quest.Request.GetQuestModelRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-0001")
        .WithQuestName("quest-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getQuestModel(
        new Gs2Quest.GetQuestModelRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_quest_model(
        quest.GetQuestModelRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
            .with_quest_name('quest-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.get_quest_model({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-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('quest')

api_result_handler = client.get_quest_model_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-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>

現在登録されているクエストグループモデルマスターおよびクエストモデルマスターを有効化可能なマスターデータ形式でエクスポートします。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentQuestMaster](#currentquestmaster) | 有効化可能なクエストモデルのマスターデータ |

#### 実装例




**Go**
```go

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

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

$session->open();

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

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

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

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

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

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


```

**GS2-Script**
```lua

client = gs2('quest')

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

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;

```



---

### getCurrentQuestMaster

現在アクティブなクエストモデルのマスターデータを取得<br>

クエストグループモデルおよびクエストモデルを含む、現在アクティブなクエストモデルのマスターデータを取得します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentQuestMaster](#currentquestmaster) | 現在アクティブなクエストモデルのマスターデータ |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetCurrentQuestMaster(
    &quest.GetCurrentQuestMasterRequest {
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetCurrentQuestMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getCurrentQuestMaster(
        (new GetCurrentQuestMasterRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetCurrentQuestMasterRequest;
import io.gs2.quest.result.GetCurrentQuestMasterResult;

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

try {
    GetCurrentQuestMasterResult result = client.getCurrentQuestMaster(
        new GetCurrentQuestMasterRequest()
            .withNamespaceName("namespace-0001")
    );
    CurrentQuestMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetCurrentQuestMasterResult> asyncResult = null;
yield return client.GetCurrentQuestMaster(
    new Gs2.Gs2Quest.Request.GetCurrentQuestMasterRequest()
        .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 Gs2Quest from '@/gs2/quest';

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

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

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_current_quest_master(
        quest.GetCurrentQuestMasterRequest()
            .with_namespace_name('namespace-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.get_current_quest_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('quest')

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

```



---

### preUpdateCurrentQuestMaster

現在アクティブなクエストモデルのマスターデータを更新（3フェーズ版）<br>

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


#### 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/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.PreUpdateCurrentQuestMaster(
    &quest.PreUpdateCurrentQuestMasterRequest {
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\PreUpdateCurrentQuestMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->preUpdateCurrentQuestMaster(
        (new PreUpdateCurrentQuestMasterRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.PreUpdateCurrentQuestMasterRequest;
import io.gs2.quest.result.PreUpdateCurrentQuestMasterResult;

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

try {
    PreUpdateCurrentQuestMasterResult result = client.preUpdateCurrentQuestMaster(
        new PreUpdateCurrentQuestMasterRequest()
            .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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.PreUpdateCurrentQuestMasterResult> asyncResult = null;
yield return client.PreUpdateCurrentQuestMaster(
    new Gs2.Gs2Quest.Request.PreUpdateCurrentQuestMasterRequest()
        .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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.preUpdateCurrentQuestMaster(
        new Gs2Quest.PreUpdateCurrentQuestMasterRequest()
            .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 quest

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

try:
    result = client.pre_update_current_quest_master(
        quest.PreUpdateCurrentQuestMasterRequest()
            .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('quest')

api_result = client.pre_update_current_quest_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('quest')

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

```



---

### updateCurrentQuestMaster

現在アクティブなクエストモデルのマスターデータを更新<br>

現在アクティブなクエストモデルのマスターデータを更新します。大容量マスターデータに対応するため、直接更新モードと事前アップロードモードの両方をサポートしています。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| mode | 文字列列挙型<br>enum {<br>"direct",<br>"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 | [CurrentQuestMaster](#currentquestmaster) | 更新された現在アクティブなクエストモデルのマスターデータ |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentQuestMaster(
    &quest.UpdateCurrentQuestMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Mode: pointy.String("direct"),
        Settings: pointy.String("{\n      \"version\": \"2019-05-14\",\n      \"groups\": [\n        {\n          \"name\": \"main\",\n          \"metadata\": \"MAIN\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 100, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 99\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 500, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeValue\\\": 5}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            },\n            {\n              \"name\": \"1-2\",\n              \"metadata\": \"stage1-2\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 200, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 98\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1000, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 2\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"consumeValue\\\": 5, \\\"userId\\\": \\\"#{userId}\\\"}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n                \"1-1\"\n              ]\n            }\n          ]\n        },\n        {\n          \"name\": \"sub\",\n          \"metadata\": \"SUB\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2JobQueue:PushByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"queue-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"jobs\\\": [{\\\"scriptId\\\": \\\"script-0001\\\", \\\"args\\\": {}, \\\"maxTryCount\\\": 3}]}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            }\n          ]\n        }\n      ]\n    }"),
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\UpdateCurrentQuestMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->updateCurrentQuestMaster(
        (new UpdateCurrentQuestMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withMode("direct")
            ->withSettings("{\n      \"version\": \"2019-05-14\",\n      \"groups\": [\n        {\n          \"name\": \"main\",\n          \"metadata\": \"MAIN\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 100, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 99\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 500, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeValue\\\": 5}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            },\n            {\n              \"name\": \"1-2\",\n              \"metadata\": \"stage1-2\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 200, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 98\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1000, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 2\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"consumeValue\\\": 5, \\\"userId\\\": \\\"#{userId}\\\"}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n                \"1-1\"\n              ]\n            }\n          ]\n        },\n        {\n          \"name\": \"sub\",\n          \"metadata\": \"SUB\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2JobQueue:PushByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"queue-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"jobs\\\": [{\\\"scriptId\\\": \\\"script-0001\\\", \\\"args\\\": {}, \\\"maxTryCount\\\": 3}]}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            }\n          ]\n        }\n      ]\n    }")
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.UpdateCurrentQuestMasterRequest;
import io.gs2.quest.result.UpdateCurrentQuestMasterResult;

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

try {
    UpdateCurrentQuestMasterResult result = client.updateCurrentQuestMaster(
        new UpdateCurrentQuestMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\n      \"version\": \"2019-05-14\",\n      \"groups\": [\n        {\n          \"name\": \"main\",\n          \"metadata\": \"MAIN\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 100, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 99\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 500, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeValue\\\": 5}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            },\n            {\n              \"name\": \"1-2\",\n              \"metadata\": \"stage1-2\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 200, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 98\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1000, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 2\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"consumeValue\\\": 5, \\\"userId\\\": \\\"#{userId}\\\"}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n                \"1-1\"\n              ]\n            }\n          ]\n        },\n        {\n          \"name\": \"sub\",\n          \"metadata\": \"SUB\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2JobQueue:PushByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"queue-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"jobs\\\": [{\\\"scriptId\\\": \\\"script-0001\\\", \\\"args\\\": {}, \\\"maxTryCount\\\": 3}]}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            }\n          ]\n        }\n      ]\n    }")
            .withUploadToken(null)
    );
    CurrentQuestMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.UpdateCurrentQuestMasterResult> asyncResult = null;
yield return client.UpdateCurrentQuestMaster(
    new Gs2.Gs2Quest.Request.UpdateCurrentQuestMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithMode("direct")
        .WithSettings("{\n      \"version\": \"2019-05-14\",\n      \"groups\": [\n        {\n          \"name\": \"main\",\n          \"metadata\": \"MAIN\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 100, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 99\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 500, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeValue\\\": 5}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            },\n            {\n              \"name\": \"1-2\",\n              \"metadata\": \"stage1-2\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 200, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 98\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1000, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 2\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"consumeValue\\\": 5, \\\"userId\\\": \\\"#{userId}\\\"}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n                \"1-1\"\n              ]\n            }\n          ]\n        },\n        {\n          \"name\": \"sub\",\n          \"metadata\": \"SUB\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2JobQueue:PushByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"queue-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"jobs\\\": [{\\\"scriptId\\\": \\\"script-0001\\\", \\\"args\\\": {}, \\\"maxTryCount\\\": 3}]}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            }\n          ]\n        }\n      ]\n    }")
        .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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.updateCurrentQuestMaster(
        new Gs2Quest.UpdateCurrentQuestMasterRequest()
            .withNamespaceName("namespace-0001")
            .withMode("direct")
            .withSettings("{\n      \"version\": \"2019-05-14\",\n      \"groups\": [\n        {\n          \"name\": \"main\",\n          \"metadata\": \"MAIN\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 100, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 99\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 500, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeValue\\\": 5}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            },\n            {\n              \"name\": \"1-2\",\n              \"metadata\": \"stage1-2\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 200, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 98\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1000, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 2\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"consumeValue\\\": 5, \\\"userId\\\": \\\"#{userId}\\\"}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n                \"1-1\"\n              ]\n            }\n          ]\n        },\n        {\n          \"name\": \"sub\",\n          \"metadata\": \"SUB\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2JobQueue:PushByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"queue-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"jobs\\\": [{\\\"scriptId\\\": \\\"script-0001\\\", \\\"args\\\": {}, \\\"maxTryCount\\\": 3}]}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            }\n          ]\n        }\n      ]\n    }")
            .withUploadToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.update_current_quest_master(
        quest.UpdateCurrentQuestMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_mode('direct')
            .with_settings('{\n      "version": "2019-05-14",\n      "groups": [\n        {\n          "name": "main",\n          "metadata": "MAIN",\n          "quests": [\n            {\n              "name": "1-1",\n              "metadata": "stage1-1",\n              "contents": [\n                {\n                  "metadata": "normal",\n                  "completeAcquireActions": [\n                    {\n                      "action": "Gs2Experience:AddExperienceByUserId",\n                      "request": "{\\"namespaceName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"experienceName\\": \\"player\\", \\"propertyId\\": \\"player\\", \\"experienceValue\\": 10}"\n                    },\n                    {\n                      "action": "Gs2Inventory:AcquireItemSetByUserId",\n                      "request": "{\\"namespaceName\\": \\"gold\\", \\"inventoryName\\": \\"wallet\\", \\"itemName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"acquireCount\\": 100, \\"expiresAt\\": null}"\n                    }\n                  ],\n                  "weight": 99\n                },\n                {\n                  "metadata": "rare",\n                  "completeAcquireActions": [\n                    {\n                      "action": "Gs2Experience:AddExperienceByUserId",\n                      "request": "{\\"namespaceName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"experienceName\\": \\"player\\", \\"propertyId\\": \\"player\\", \\"experienceValue\\": 10}"\n                    },\n                    {\n                      "action": "Gs2Inventory:AcquireItemSetByUserId",\n                      "request": "{\\"namespaceName\\": \\"gold\\", \\"inventoryName\\": \\"wallet\\", \\"itemName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"acquireCount\\": 500, \\"expiresAt\\": null}"\n                    }\n                  ],\n                  "weight": 1\n                }\n              ],\n              "consumeActions": [\n                {\n                  "action": "Gs2Stamina:ConsumeStaminaByUserId",\n                  "request": "{\\"namespaceName\\": \\"basic\\", \\"staminaName\\": \\"quest\\", \\"userId\\": \\"#{userId}\\", \\"consumeValue\\": 5}"\n                }\n              ],\n              "failedAcquireActions": [\n                {\n                  "action": "Gs2Stamina:RecoverStaminaByUserId",\n                  "request": "{\\"namespaceName\\": \\"basic\\", \\"staminaName\\": \\"quest\\", \\"userId\\": \\"#{userId}\\", \\"recoverValue\\": 5}"\n                }\n              ],\n              "premiseQuestNames": [\n              ]\n            },\n            {\n              "name": "1-2",\n              "metadata": "stage1-2",\n              "contents": [\n                {\n                  "metadata": "normal",\n                  "completeAcquireActions": [\n                    {\n                      "action": "Gs2Experience:AddExperienceByUserId",\n                      "request": "{\\"namespaceName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"experienceName\\": \\"player\\", \\"propertyId\\": \\"player\\", \\"experienceValue\\": 20}"\n                    },\n                    {\n                      "action": "Gs2Inventory:AcquireItemSetByUserId",\n                      "request": "{\\"namespaceName\\": \\"gold\\", \\"inventoryName\\": \\"wallet\\", \\"itemName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"acquireCount\\": 200, \\"expiresAt\\": null}"\n                    }\n                  ],\n                  "weight": 98\n                },\n                {\n                  "metadata": "rare",\n                  "completeAcquireActions": [\n                    {\n                      "action": "Gs2Experience:AddExperienceByUserId",\n                      "request": "{\\"namespaceName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"experienceName\\": \\"player\\", \\"propertyId\\": \\"player\\", \\"experienceValue\\": 20}"\n                    },\n                    {\n                      "action": "Gs2Inventory:AcquireItemSetByUserId",\n                      "request": "{\\"namespaceName\\": \\"gold\\", \\"inventoryName\\": \\"wallet\\", \\"itemName\\": \\"basic\\", \\"userId\\": \\"#{userId}\\", \\"acquireCount\\": 1000, \\"expiresAt\\": null}"\n                    }\n                  ],\n                  "weight": 2\n                }\n              ],\n              "consumeActions": [\n                {\n                  "action": "Gs2Stamina:ConsumeStaminaByUserId",\n                  "request": "{\\"namespaceName\\": \\"basic\\", \\"staminaName\\": \\"quest\\", \\"consumeValue\\": 5, \\"userId\\": \\"#{userId}\\"}"\n                }\n              ],\n              "failedAcquireActions": [\n                {\n                  "action": "Gs2Stamina:RecoverStaminaByUserId",\n                  "request": "{\\"namespaceName\\": \\"basic\\", \\"staminaName\\": \\"quest\\", \\"userId\\": \\"#{userId}\\", \\"recoverValue\\": 5}"\n                }\n              ],\n              "premiseQuestNames": [\n                "1-1"\n              ]\n            }\n          ]\n        },\n        {\n          "name": "sub",\n          "metadata": "SUB",\n          "quests": [\n            {\n              "name": "1-1",\n              "metadata": "stage1-1",\n              "contents": [\n                {\n                  "metadata": "normal",\n                  "completeAcquireActions": [\n                    {\n                      "action": "Gs2JobQueue:PushByUserId",\n                      "request": "{\\"namespaceName\\": \\"queue-0001\\", \\"userId\\": \\"#{userId}\\", \\"jobs\\": [{\\"scriptId\\": \\"script-0001\\", \\"args\\": {}, \\"maxTryCount\\": 3}]}"\n                    }\n                  ],\n                  "weight": 1\n                }\n              ],\n              "premiseQuestNames": [\n              ]\n            }\n          ]\n        }\n      ]\n    }')
            .with_upload_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.update_current_quest_master({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\n      \"version\": \"2019-05-14\",\n      \"groups\": [\n        {\n          \"name\": \"main\",\n          \"metadata\": \"MAIN\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 100, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 99\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 500, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeValue\\\": 5}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            },\n            {\n              \"name\": \"1-2\",\n              \"metadata\": \"stage1-2\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 200, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 98\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1000, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 2\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"consumeValue\\\": 5, \\\"userId\\\": \\\"#{userId}\\\"}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n                \"1-1\"\n              ]\n            }\n          ]\n        },\n        {\n          \"name\": \"sub\",\n          \"metadata\": \"SUB\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2JobQueue:PushByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"queue-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"jobs\\\": [{\\\"scriptId\\\": \\\"script-0001\\\", \\\"args\\\": {}, \\\"maxTryCount\\\": 3}]}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            }\n          ]\n        }\n      ]\n    }",
    uploadToken=nil,
})

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

result = api_result.result
item = result.item;

```

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

client = gs2('quest')

api_result_handler = client.update_current_quest_master_async({
    namespaceName="namespace-0001",
    mode="direct",
    settings="{\n      \"version\": \"2019-05-14\",\n      \"groups\": [\n        {\n          \"name\": \"main\",\n          \"metadata\": \"MAIN\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 100, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 99\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 10}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 500, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeValue\\\": 5}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            },\n            {\n              \"name\": \"1-2\",\n              \"metadata\": \"stage1-2\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 200, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 98\n                },\n                {\n                  \"metadata\": \"rare\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2Experience:AddExperienceByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"experienceName\\\": \\\"player\\\", \\\"propertyId\\\": \\\"player\\\", \\\"experienceValue\\\": 20}\"\n                    },\n                    {\n                      \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"gold\\\", \\\"inventoryName\\\": \\\"wallet\\\", \\\"itemName\\\": \\\"basic\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1000, \\\"expiresAt\\\": null}\"\n                    }\n                  ],\n                  \"weight\": 2\n                }\n              ],\n              \"consumeActions\": [\n                {\n                  \"action\": \"Gs2Stamina:ConsumeStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"consumeValue\\\": 5, \\\"userId\\\": \\\"#{userId}\\\"}\"\n                }\n              ],\n              \"failedAcquireActions\": [\n                {\n                  \"action\": \"Gs2Stamina:RecoverStaminaByUserId\",\n                  \"request\": \"{\\\"namespaceName\\\": \\\"basic\\\", \\\"staminaName\\\": \\\"quest\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"recoverValue\\\": 5}\"\n                }\n              ],\n              \"premiseQuestNames\": [\n                \"1-1\"\n              ]\n            }\n          ]\n        },\n        {\n          \"name\": \"sub\",\n          \"metadata\": \"SUB\",\n          \"quests\": [\n            {\n              \"name\": \"1-1\",\n              \"metadata\": \"stage1-1\",\n              \"contents\": [\n                {\n                  \"metadata\": \"normal\",\n                  \"completeAcquireActions\": [\n                    {\n                      \"action\": \"Gs2JobQueue:PushByUserId\",\n                      \"request\": \"{\\\"namespaceName\\\": \\\"queue-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"jobs\\\": [{\\\"scriptId\\\": \\\"script-0001\\\", \\\"args\\\": {}, \\\"maxTryCount\\\": 3}]}\"\n                    }\n                  ],\n                  \"weight\": 1\n                }\n              ],\n              \"premiseQuestNames\": [\n              ]\n            }\n          ]\n        }\n      ]\n    }",
    uploadToken=nil,
})

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

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

result = api_result.result
item = result.item;

```



---

### updateCurrentQuestMasterFromGitHub

現在アクティブなクエストモデルのマスターデータをGitHubから更新<br>

指定されたチェックアウト設定を使用して GitHub リポジトリからマスターデータをチェックアウトし、現在アクティブなクエストモデルのマスターデータを更新します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentQuestMaster](#currentquestmaster) | 更新された現在アクティブなクエストモデルのマスターデータ |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.UpdateCurrentQuestMasterFromGitHub(
    &quest.UpdateCurrentQuestMasterFromGitHubRequest {
        NamespaceName: pointy.String("namespace-0001"),
        CheckoutSetting: &quest.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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\UpdateCurrentQuestMasterFromGitHubRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->updateCurrentQuestMasterFromGitHub(
        (new UpdateCurrentQuestMasterFromGitHubRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.UpdateCurrentQuestMasterFromGitHubRequest;
import io.gs2.quest.result.UpdateCurrentQuestMasterFromGitHubResult;

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

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

AsyncResult<Gs2.Gs2Quest.Result.UpdateCurrentQuestMasterFromGitHubResult> asyncResult = null;
yield return client.UpdateCurrentQuestMasterFromGitHub(
    new Gs2.Gs2Quest.Request.UpdateCurrentQuestMasterFromGitHubRequest()
        .WithNamespaceName("namespace-0001")
        .WithCheckoutSetting(new Gs2.Gs2Quest.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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.updateCurrentQuestMasterFromGitHub(
        new Gs2Quest.UpdateCurrentQuestMasterFromGitHubRequest()
            .withNamespaceName("namespace-0001")
            .withCheckoutSetting(new Gs2Quest.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 quest

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

try:
    result = client.update_current_quest_master_from_git_hub(
        quest.UpdateCurrentQuestMasterFromGitHubRequest()
            .with_namespace_name('namespace-0001')
            .with_checkout_setting(quest.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('quest')

api_result = client.update_current_quest_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('quest')

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

```



---

### describeQuestGroupModelMasters

クエストグループモデルマスターの一覧を取得<br>

クエストグループモデルマスターのページネーション付きリストを取得します。名前のプレフィックスでフィルタリングできます。


#### Request

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

#### Result

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

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DescribeQuestGroupModelMasters(
    &quest.DescribeQuestGroupModelMastersRequest {
        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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DescribeQuestGroupModelMastersRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->describeQuestGroupModelMasters(
        (new DescribeQuestGroupModelMastersRequest())
            ->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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DescribeQuestGroupModelMastersRequest;
import io.gs2.quest.result.DescribeQuestGroupModelMastersResult;

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

try {
    DescribeQuestGroupModelMastersResult result = client.describeQuestGroupModelMasters(
        new DescribeQuestGroupModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    List<QuestGroupModelMaster> 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DescribeQuestGroupModelMastersResult> asyncResult = null;
yield return client.DescribeQuestGroupModelMasters(
    new Gs2.Gs2Quest.Request.DescribeQuestGroupModelMastersRequest()
        .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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.describeQuestGroupModelMasters(
        new Gs2Quest.DescribeQuestGroupModelMastersRequest()
            .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 quest

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

try:
    result = client.describe_quest_group_model_masters(
        quest.DescribeQuestGroupModelMastersRequest()
            .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('quest')

api_result = client.describe_quest_group_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('quest')

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

```



---

### createQuestGroupModelMaster

クエストグループモデルマスターを新規作成<br>

指定した名前、説明、メタデータ、およびオプションのチャレンジ期間イベント設定を持つ新しいクエストグループモデルマスターを作成します。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名<br>クエストグループモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| challengePeriodEventId | string |  | |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このグループ内のクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestGroupModelMaster](#questgroupmodelmaster) | 作成したクエストグループモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.CreateQuestGroupModelMaster(
    &quest.CreateQuestGroupModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        Name: pointy.String("quest-group-0001"),
        Description: nil,
        Metadata: nil,
        ChallengePeriodEventId: 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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\CreateQuestGroupModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->createQuestGroupModelMaster(
        (new CreateQuestGroupModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withName("quest-group-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withChallengePeriodEventId(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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.CreateQuestGroupModelMasterRequest;
import io.gs2.quest.result.CreateQuestGroupModelMasterResult;

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

try {
    CreateQuestGroupModelMasterResult result = client.createQuestGroupModelMaster(
        new CreateQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("quest-group-0001")
            .withDescription(null)
            .withMetadata(null)
            .withChallengePeriodEventId(null)
    );
    QuestGroupModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.CreateQuestGroupModelMasterResult> asyncResult = null;
yield return client.CreateQuestGroupModelMaster(
    new Gs2.Gs2Quest.Request.CreateQuestGroupModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithName("quest-group-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithChallengePeriodEventId(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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.createQuestGroupModelMaster(
        new Gs2Quest.CreateQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withName("quest-group-0001")
            .withDescription(null)
            .withMetadata(null)
            .withChallengePeriodEventId(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.create_quest_group_model_master(
        quest.CreateQuestGroupModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_name('quest-group-0001')
            .with_description(None)
            .with_metadata(None)
            .with_challenge_period_event_id(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.create_quest_group_model_master({
    namespaceName="namespace-0001",
    name="quest-group-0001",
    description=nil,
    metadata=nil,
    challengePeriodEventId=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('quest')

api_result_handler = client.create_quest_group_model_master_async({
    namespaceName="namespace-0001",
    name="quest-group-0001",
    description=nil,
    metadata=nil,
    challengePeriodEventId=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;

```



---

### getQuestGroupModelMaster

クエストグループモデルマスターを取得<br>

指定されたクエストグループモデルマスターを取得します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestGroupModelMaster](#questgroupmodelmaster) | クエストグループモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetQuestGroupModelMaster(
    &quest.GetQuestGroupModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetQuestGroupModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getQuestGroupModelMaster(
        (new GetQuestGroupModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetQuestGroupModelMasterRequest;
import io.gs2.quest.result.GetQuestGroupModelMasterResult;

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

try {
    GetQuestGroupModelMasterResult result = client.getQuestGroupModelMaster(
        new GetQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    QuestGroupModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetQuestGroupModelMasterResult> asyncResult = null;
yield return client.GetQuestGroupModelMaster(
    new Gs2.Gs2Quest.Request.GetQuestGroupModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getQuestGroupModelMaster(
        new Gs2Quest.GetQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_quest_group_model_master(
        quest.GetQuestGroupModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.get_quest_group_model_master({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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('quest')

api_result_handler = client.get_quest_group_model_master_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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;

```



---

### updateQuestGroupModelMaster

クエストグループモデルマスターを更新<br>

指定されたクエストグループモデルマスターの説明、メタデータ、チャレンジ期間イベント設定を更新します。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名<br>クエストグループモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| challengePeriodEventId | string |  | |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このグループ内のクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestGroupModelMaster](#questgroupmodelmaster) | 更新したクエストグループモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.UpdateQuestGroupModelMaster(
    &quest.UpdateQuestGroupModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-0001"),
        Description: pointy.String("description1"),
        Metadata: nil,
        ChallengePeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002"),
    }
)
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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\UpdateQuestGroupModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->updateQuestGroupModelMaster(
        (new UpdateQuestGroupModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-0001")
            ->withDescription("description1")
            ->withMetadata(null)
            ->withChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
    );
    $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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.UpdateQuestGroupModelMasterRequest;
import io.gs2.quest.result.UpdateQuestGroupModelMasterResult;

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

try {
    UpdateQuestGroupModelMasterResult result = client.updateQuestGroupModelMaster(
        new UpdateQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
    );
    QuestGroupModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.UpdateQuestGroupModelMasterResult> asyncResult = null;
yield return client.UpdateQuestGroupModelMaster(
    new Gs2.Gs2Quest.Request.UpdateQuestGroupModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-0001")
        .WithDescription("description1")
        .WithMetadata(null)
        .WithChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002"),
    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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.updateQuestGroupModelMaster(
        new Gs2Quest.UpdateQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.update_quest_group_model_master(
        quest.UpdateQuestGroupModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
            .with_description('description1')
            .with_metadata(None)
            .with_challenge_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.update_quest_group_model_master({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    description="description1",
    metadata=nil,
    challengePeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
})

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

api_result_handler = client.update_quest_group_model_master_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    description="description1",
    metadata=nil,
    challengePeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
})

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

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

result = api_result.result
item = result.item;

```



---

### deleteQuestGroupModelMaster

クエストグループモデルマスターを削除<br>

指定されたクエストグループモデルマスターを削除します。グループ内のすべてのクエストモデルマスターも同時に削除されます。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestGroupModelMaster](#questgroupmodelmaster) | 削除したクエストグループモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DeleteQuestGroupModelMaster(
    &quest.DeleteQuestGroupModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DeleteQuestGroupModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->deleteQuestGroupModelMaster(
        (new DeleteQuestGroupModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DeleteQuestGroupModelMasterRequest;
import io.gs2.quest.result.DeleteQuestGroupModelMasterResult;

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

try {
    DeleteQuestGroupModelMasterResult result = client.deleteQuestGroupModelMaster(
        new DeleteQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    QuestGroupModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DeleteQuestGroupModelMasterResult> asyncResult = null;
yield return client.DeleteQuestGroupModelMaster(
    new Gs2.Gs2Quest.Request.DeleteQuestGroupModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.deleteQuestGroupModelMaster(
        new Gs2Quest.DeleteQuestGroupModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.delete_quest_group_model_master(
        quest.DeleteQuestGroupModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.delete_quest_group_model_master({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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('quest')

api_result_handler = client.delete_quest_group_model_master_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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;

```



---

### describeQuestModelMasters

クエストモデルマスターの一覧を取得<br>

指定したクエストグループ内のクエストモデルマスターのページネーション付きリストを取得します。名前のプレフィックスでフィルタリングできます。


#### Request

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

#### Result

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

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DescribeQuestModelMasters(
    &quest.DescribeQuestModelMastersRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DescribeQuestModelMastersRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->describeQuestModelMasters(
        (new DescribeQuestModelMastersRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DescribeQuestModelMastersRequest;
import io.gs2.quest.result.DescribeQuestModelMastersResult;

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

try {
    DescribeQuestModelMastersResult result = client.describeQuestModelMasters(
        new DescribeQuestModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withNamePrefix(null)
            .withPageToken(null)
            .withLimit(null)
    );
    List<QuestModelMaster> 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DescribeQuestModelMastersResult> asyncResult = null;
yield return client.DescribeQuestModelMasters(
    new Gs2.Gs2Quest.Request.DescribeQuestModelMastersRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.describeQuestModelMasters(
        new Gs2Quest.DescribeQuestModelMastersRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-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 quest

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

try:
    result = client.describe_quest_model_masters(
        quest.DescribeQuestModelMastersRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-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('quest')

api_result = client.describe_quest_model_masters({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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('quest')

api_result_handler = client.describe_quest_model_masters_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-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;

```



---

### createQuestModelMaster

クエストモデルマスターを新規作成<br>

コンテンツ定義、報酬設定、消費アクション、検証アクション、失敗時入手アクション、前提クエスト名を持つ新しいクエストモデルマスターを作成します。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名<br>クエストグループモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string |  | ✓|  |  ~ 128文字 | クエストモデル名<br>クエストモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| contents | [List&lt;Contents&gt;](#contents) |  | ✓|  | 1 ~ 10 items | クエストの内容<br>このクエストのコンテンツバリエーションのリストです。クエスト開始時に重み付き抽選で1つのバリエーションが選択されます。各バリエーションに異なるクリア報酬を定義でき、同じクエストでも異なる結果（例：レアモンスターの出現）を実現できます。 |
| challengePeriodEventId | string |  | |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。この設定はクエストグループの挑戦可能期間より優先されます。 |
| firstCompleteAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  | | [] | 0 ~ 10 items | 初回クリア報酬入手アクションリスト<br>このクエストの初回クリア時にのみ実行される入手アクションのリストです。通常のクリア報酬に加えて付与されるボーナス報酬で、初回クリアボーナスの実現に使用します。 |
| verifyActions | [List&lt;VerifyAction&gt;](#verifyaction) |  | | [] | 0 ~ 10 items | 検証アクションリスト<br>このクエストを開始するための前提条件となる検証アクションのリストです。すべての検証アクションが成功しないとクエストを開始できません。レベル確認やアイテム所持などの要件の強制に使用します。 |
| consumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) |  | | [] | 0 ~ 10 items | 消費アクションリスト<br>このクエストの開始コストとして実行される消費アクションです。スタミナや通貨などのコストがクエスト開始時に消費されます。 |
| failedAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  | | [] | 0 ~ 100 items | 失敗時入手アクションリスト<br>クエスト失敗時に実行される入手アクションです。失敗時の慰労報酬やクエスト参加コストの一部返還などに使用します。 |
| premiseQuestNames | List&lt;string&gt; |  | | [] | 0 ~ 10 items | 前提クエスト名リスト<br>このクエストに挑戦する前にクリアが必要な同グループ内のクエスト名のリストです。連続するクエストチェーンや分岐するクエストパスの作成に使用します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestModelMaster](#questmodelmaster) | 作成したクエストモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.CreateQuestModelMaster(
    &quest.CreateQuestModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-0001"),
        Name: pointy.String("quest-0001"),
        Description: nil,
        Metadata: nil,
        Contents: []quest.Contents{
            quest.Contents{
                Metadata: pointy.String("normal"),
                CompleteAcquireActions: []quest.AcquireAction{
                    quest.AcquireAction{
                        Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
                        Request: pointy.String("Gs2Experience:AddExperienceByUserId-request1"),
                    },
                },
                Weight: pointy.Int32(1),
            },
        },
        ChallengePeriodEventId: nil,
        FirstCompleteAcquireActions: nil,
        VerifyActions: nil,
        ConsumeActions: nil,
        FailedAcquireActions: nil,
        PremiseQuestNames: 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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\CreateQuestModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->createQuestModelMaster(
        (new CreateQuestModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-0001")
            ->withName("quest-0001")
            ->withDescription(null)
            ->withMetadata(null)
            ->withContents([
                (new \Gs2\Quest\Model\Contents())
                    ->withMetadata("normal")
                    ->withCompleteAcquireActions([
                        (new \Gs2\Quest\Model\AcquireAction())
                            ->withAction("Gs2Experience:AddExperienceByUserId")
                            ->withRequest("Gs2Experience:AddExperienceByUserId-request1"),
                    ])
                    ->withWeight(1),
            ])
            ->withChallengePeriodEventId(null)
            ->withFirstCompleteAcquireActions(null)
            ->withVerifyActions(null)
            ->withConsumeActions(null)
            ->withFailedAcquireActions(null)
            ->withPremiseQuestNames(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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.CreateQuestModelMasterRequest;
import io.gs2.quest.result.CreateQuestModelMasterResult;

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

try {
    CreateQuestModelMasterResult result = client.createQuestModelMaster(
        new CreateQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withName("quest-0001")
            .withDescription(null)
            .withMetadata(null)
            .withContents(Arrays.asList(
                new io.gs2.quest.model.Contents()
                    .withMetadata("normal")
                    .withCompleteAcquireActions(Arrays.asList(
                        new io.gs2.quest.model.AcquireAction()
                            .withAction("Gs2Experience:AddExperienceByUserId")
                            .withRequest("Gs2Experience:AddExperienceByUserId-request1")
                    ))
                    .withWeight(1)
            ))
            .withChallengePeriodEventId(null)
            .withFirstCompleteAcquireActions(null)
            .withVerifyActions(null)
            .withConsumeActions(null)
            .withFailedAcquireActions(null)
            .withPremiseQuestNames(null)
    );
    QuestModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.CreateQuestModelMasterResult> asyncResult = null;
yield return client.CreateQuestModelMaster(
    new Gs2.Gs2Quest.Request.CreateQuestModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-0001")
        .WithName("quest-0001")
        .WithDescription(null)
        .WithMetadata(null)
        .WithContents(new Gs2.Gs2Quest.Model.Contents[] {
            new Gs2.Gs2Quest.Model.Contents()
                .WithMetadata("normal")
                .WithCompleteAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Experience:AddExperienceByUserId")
                        .WithRequest("Gs2Experience:AddExperienceByUserId-request1"),
                })
                .WithWeight(1),
        })
        .WithChallengePeriodEventId(null)
        .WithFirstCompleteAcquireActions(null)
        .WithVerifyActions(null)
        .WithConsumeActions(null)
        .WithFailedAcquireActions(null)
        .WithPremiseQuestNames(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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.createQuestModelMaster(
        new Gs2Quest.CreateQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withName("quest-0001")
            .withDescription(null)
            .withMetadata(null)
            .withContents([
                new Gs2Quest.model.Contents()
                    .withMetadata("normal")
                    .withCompleteAcquireActions([
                        new Gs2Quest.model.AcquireAction()
                            .withAction("Gs2Experience:AddExperienceByUserId")
                            .withRequest("Gs2Experience:AddExperienceByUserId-request1"),
                    ])
                    .withWeight(1),
            ])
            .withChallengePeriodEventId(null)
            .withFirstCompleteAcquireActions(null)
            .withVerifyActions(null)
            .withConsumeActions(null)
            .withFailedAcquireActions(null)
            .withPremiseQuestNames(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.create_quest_model_master(
        quest.CreateQuestModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
            .with_name('quest-0001')
            .with_description(None)
            .with_metadata(None)
            .with_contents([
                quest.Contents()
                    .with_metadata('normal')
                    .with_complete_acquire_actions([
                        quest.AcquireAction()
                            .with_action('Gs2Experience:AddExperienceByUserId')
                            .with_request('Gs2Experience:AddExperienceByUserId-request1'),
                    ])
                    .with_weight(1),
            ])
            .with_challenge_period_event_id(None)
            .with_first_complete_acquire_actions(None)
            .with_verify_actions(None)
            .with_consume_actions(None)
            .with_failed_acquire_actions(None)
            .with_premise_quest_names(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.create_quest_model_master({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    name="quest-0001",
    description=nil,
    metadata=nil,
    contents={
        {
            metadata="normal",
            completeAcquireActions={
                {
                    action="Gs2Experience:AddExperienceByUserId",
                    request="Gs2Experience:AddExperienceByUserId-request1",
                }
            },
            weight=1,
        }
    },
    challengePeriodEventId=nil,
    firstCompleteAcquireActions=nil,
    verifyActions=nil,
    consumeActions=nil,
    failedAcquireActions=nil,
    premiseQuestNames=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('quest')

api_result_handler = client.create_quest_model_master_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    name="quest-0001",
    description=nil,
    metadata=nil,
    contents={
        {
            metadata="normal",
            completeAcquireActions={
                {
                    action="Gs2Experience:AddExperienceByUserId",
                    request="Gs2Experience:AddExperienceByUserId-request1",
                }
            },
            weight=1,
        }
    },
    challengePeriodEventId=nil,
    firstCompleteAcquireActions=nil,
    verifyActions=nil,
    consumeActions=nil,
    failedAcquireActions=nil,
    premiseQuestNames=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;

```



---

### getQuestModelMaster

クエストモデルマスターを取得<br>

コンテンツ定義、報酬設定、前提条件を含む、指定されたクエストモデルマスターを取得します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestModelMaster](#questmodelmaster) | クエストモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.GetQuestModelMaster(
    &quest.GetQuestModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-0001"),
        QuestName: pointy.String("quest-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\GetQuestModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->getQuestModelMaster(
        (new GetQuestModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-0001")
            ->withQuestName("quest-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.GetQuestModelMasterRequest;
import io.gs2.quest.result.GetQuestModelMasterResult;

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

try {
    GetQuestModelMasterResult result = client.getQuestModelMaster(
        new GetQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
    );
    QuestModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.GetQuestModelMasterResult> asyncResult = null;
yield return client.GetQuestModelMaster(
    new Gs2.Gs2Quest.Request.GetQuestModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-0001")
        .WithQuestName("quest-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.getQuestModelMaster(
        new Gs2Quest.GetQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.get_quest_model_master(
        quest.GetQuestModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
            .with_quest_name('quest-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.get_quest_model_master({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-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('quest')

api_result_handler = client.get_quest_model_master_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-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;

```



---

### updateQuestModelMaster

クエストモデルマスターを更新<br>

指定されたクエストモデルマスターのコンテンツ定義、報酬設定、消費アクション、検証アクション、失敗時入手アクション、前提クエスト名を更新します。


#### Request

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questGroupName | string |  | ✓|  |  ~ 128文字 | クエストグループモデル名<br>クエストグループモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| questName | string |  | ✓|  |  ~ 128文字 | クエストモデル名<br>クエストモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string |  | |  |  ~ 1024文字 | 説明文 |
| metadata | string |  | |  |  ~ 1024文字 | メタデータ<br>メタデータには任意の値を設定できます。<br>これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| contents | [List&lt;Contents&gt;](#contents) |  | ✓|  | 1 ~ 10 items | クエストの内容<br>このクエストのコンテンツバリエーションのリストです。クエスト開始時に重み付き抽選で1つのバリエーションが選択されます。各バリエーションに異なるクリア報酬を定義でき、同じクエストでも異なる結果（例：レアモンスターの出現）を実現できます。 |
| challengePeriodEventId | string |  | |  |  ~ 1024文字 | 挑戦可能期間イベントGRN<br>このクエストに挑戦可能な期間を設定する GS2-Schedule のイベントGRNです。指定した場合、イベントがアクティブな期間中のみクエストを開始できます。この設定はクエストグループの挑戦可能期間より優先されます。 |
| firstCompleteAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  | | [] | 0 ~ 10 items | 初回クリア報酬入手アクションリスト<br>このクエストの初回クリア時にのみ実行される入手アクションのリストです。通常のクリア報酬に加えて付与されるボーナス報酬で、初回クリアボーナスの実現に使用します。 |
| verifyActions | [List&lt;VerifyAction&gt;](#verifyaction) |  | | [] | 0 ~ 10 items | 検証アクションリスト<br>このクエストを開始するための前提条件となる検証アクションのリストです。すべての検証アクションが成功しないとクエストを開始できません。レベル確認やアイテム所持などの要件の強制に使用します。 |
| consumeActions | [List&lt;ConsumeAction&gt;](#consumeaction) |  | | [] | 0 ~ 10 items | 消費アクションリスト<br>このクエストの開始コストとして実行される消費アクションです。スタミナや通貨などのコストがクエスト開始時に消費されます。 |
| failedAcquireActions | [List&lt;AcquireAction&gt;](#acquireaction) |  | | [] | 0 ~ 100 items | 失敗時入手アクションリスト<br>クエスト失敗時に実行される入手アクションです。失敗時の慰労報酬やクエスト参加コストの一部返還などに使用します。 |
| premiseQuestNames | List&lt;string&gt; |  | | [] | 0 ~ 10 items | 前提クエスト名リスト<br>このクエストに挑戦する前にクリアが必要な同グループ内のクエスト名のリストです。連続するクエストチェーンや分岐するクエストパスの作成に使用します。 |

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestModelMaster](#questmodelmaster) | 更新したクエストモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.UpdateQuestModelMaster(
    &quest.UpdateQuestModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-0001"),
        QuestName: pointy.String("quest-0001"),
        Description: pointy.String("description1"),
        Metadata: nil,
        Contents: []quest.Contents{
            quest.Contents{
                Metadata: pointy.String("normal"),
                CompleteAcquireActions: []quest.AcquireAction{
                    quest.AcquireAction{
                        Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
                        Request: pointy.String("Gs2Experience:AddExperienceByUserId-request1"),
                    },
                },
                Weight: pointy.Int32(1),
            },
        },
        ChallengePeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002"),
        FirstCompleteAcquireActions: nil,
        VerifyActions: nil,
        ConsumeActions: nil,
        FailedAcquireActions: nil,
        PremiseQuestNames: 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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\UpdateQuestModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->updateQuestModelMaster(
        (new UpdateQuestModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-0001")
            ->withQuestName("quest-0001")
            ->withDescription("description1")
            ->withMetadata(null)
            ->withContents([
                (new \Gs2\Quest\Model\Contents())
                    ->withMetadata("normal")
                    ->withCompleteAcquireActions([
                        (new \Gs2\Quest\Model\AcquireAction())
                            ->withAction("Gs2Experience:AddExperienceByUserId")
                            ->withRequest("Gs2Experience:AddExperienceByUserId-request1"),
                    ])
                    ->withWeight(1),
            ])
            ->withChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
            ->withFirstCompleteAcquireActions(null)
            ->withVerifyActions(null)
            ->withConsumeActions(null)
            ->withFailedAcquireActions(null)
            ->withPremiseQuestNames(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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.UpdateQuestModelMasterRequest;
import io.gs2.quest.result.UpdateQuestModelMasterResult;

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

try {
    UpdateQuestModelMasterResult result = client.updateQuestModelMaster(
        new UpdateQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withContents(Arrays.asList(
                new io.gs2.quest.model.Contents()
                    .withMetadata("normal")
                    .withCompleteAcquireActions(Arrays.asList(
                        new io.gs2.quest.model.AcquireAction()
                            .withAction("Gs2Experience:AddExperienceByUserId")
                            .withRequest("Gs2Experience:AddExperienceByUserId-request1")
                    ))
                    .withWeight(1)
            ))
            .withChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
            .withFirstCompleteAcquireActions(null)
            .withVerifyActions(null)
            .withConsumeActions(null)
            .withFailedAcquireActions(null)
            .withPremiseQuestNames(null)
    );
    QuestModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.UpdateQuestModelMasterResult> asyncResult = null;
yield return client.UpdateQuestModelMaster(
    new Gs2.Gs2Quest.Request.UpdateQuestModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-0001")
        .WithQuestName("quest-0001")
        .WithDescription("description1")
        .WithMetadata(null)
        .WithContents(new Gs2.Gs2Quest.Model.Contents[] {
            new Gs2.Gs2Quest.Model.Contents()
                .WithMetadata("normal")
                .WithCompleteAcquireActions(new Gs2.Core.Model.AcquireAction[] {
                    new Gs2.Core.Model.AcquireAction()
                        .WithAction("Gs2Experience:AddExperienceByUserId")
                        .WithRequest("Gs2Experience:AddExperienceByUserId-request1"),
                })
                .WithWeight(1),
        })
        .WithChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
        .WithFirstCompleteAcquireActions(null)
        .WithVerifyActions(null)
        .WithConsumeActions(null)
        .WithFailedAcquireActions(null)
        .WithPremiseQuestNames(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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.updateQuestModelMaster(
        new Gs2Quest.UpdateQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
            .withDescription("description1")
            .withMetadata(null)
            .withContents([
                new Gs2Quest.model.Contents()
                    .withMetadata("normal")
                    .withCompleteAcquireActions([
                        new Gs2Quest.model.AcquireAction()
                            .withAction("Gs2Experience:AddExperienceByUserId")
                            .withRequest("Gs2Experience:AddExperienceByUserId-request1"),
                    ])
                    .withWeight(1),
            ])
            .withChallengePeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
            .withFirstCompleteAcquireActions(null)
            .withVerifyActions(null)
            .withConsumeActions(null)
            .withFailedAcquireActions(null)
            .withPremiseQuestNames(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.update_quest_model_master(
        quest.UpdateQuestModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
            .with_quest_name('quest-0001')
            .with_description('description1')
            .with_metadata(None)
            .with_contents([
                quest.Contents()
                    .with_metadata('normal')
                    .with_complete_acquire_actions([
                        quest.AcquireAction()
                            .with_action('Gs2Experience:AddExperienceByUserId')
                            .with_request('Gs2Experience:AddExperienceByUserId-request1'),
                    ])
                    .with_weight(1),
            ])
            .with_challenge_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002')
            .with_first_complete_acquire_actions(None)
            .with_verify_actions(None)
            .with_consume_actions(None)
            .with_failed_acquire_actions(None)
            .with_premise_quest_names(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.update_quest_model_master({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-0001",
    description="description1",
    metadata=nil,
    contents={
        {
            metadata="normal",
            completeAcquireActions={
                {
                    action="Gs2Experience:AddExperienceByUserId",
                    request="Gs2Experience:AddExperienceByUserId-request1",
                }
            },
            weight=1,
        }
    },
    challengePeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
    firstCompleteAcquireActions=nil,
    verifyActions=nil,
    consumeActions=nil,
    failedAcquireActions=nil,
    premiseQuestNames=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('quest')

api_result_handler = client.update_quest_model_master_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-0001",
    description="description1",
    metadata=nil,
    contents={
        {
            metadata="normal",
            completeAcquireActions={
                {
                    action="Gs2Experience:AddExperienceByUserId",
                    request="Gs2Experience:AddExperienceByUserId-request1",
                }
            },
            weight=1,
        }
    },
    challengePeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
    firstCompleteAcquireActions=nil,
    verifyActions=nil,
    consumeActions=nil,
    failedAcquireActions=nil,
    premiseQuestNames=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;

```



---

### deleteQuestModelMaster

クエストモデルマスターを削除<br>

指定されたクエストモデルマスターをクエストグループから削除します。


#### Request

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

#### Result

|  | 型 | 説明 |
| --- | --- | --- |
| item | [QuestModelMaster](#questmodelmaster) | 削除したクエストモデルマスター |

#### 実装例




**Go**
```go

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/quest"
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 := quest.Gs2QuestRestClient{
    Session: &session,
}
result, err := client.DeleteQuestModelMaster(
    &quest.DeleteQuestModelMasterRequest {
        NamespaceName: pointy.String("namespace-0001"),
        QuestGroupName: pointy.String("quest-group-0001"),
        QuestName: pointy.String("quest-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\Quest\Gs2QuestRestClient;
use Gs2\Quest\Request\DeleteQuestModelMasterRequest;

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

$session->open();

$client = new Gs2QuestRestClient(
    $session
);

try {
    $result = $client->deleteQuestModelMaster(
        (new DeleteQuestModelMasterRequest())
            ->withNamespaceName("namespace-0001")
            ->withQuestGroupName("quest-group-0001")
            ->withQuestName("quest-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.quest.rest.Gs2QuestRestClient;
import io.gs2.quest.request.DeleteQuestModelMasterRequest;
import io.gs2.quest.result.DeleteQuestModelMasterResult;

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

try {
    DeleteQuestModelMasterResult result = client.deleteQuestModelMaster(
        new DeleteQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
    );
    QuestModelMaster 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 Gs2QuestRestClient(session);

AsyncResult<Gs2.Gs2Quest.Result.DeleteQuestModelMasterResult> asyncResult = null;
yield return client.DeleteQuestModelMaster(
    new Gs2.Gs2Quest.Request.DeleteQuestModelMasterRequest()
        .WithNamespaceName("namespace-0001")
        .WithQuestGroupName("quest-group-0001")
        .WithQuestName("quest-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 Gs2Quest from '@/gs2/quest';

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

try {
    const result = await client.deleteQuestModelMaster(
        new Gs2Quest.DeleteQuestModelMasterRequest()
            .withNamespaceName("namespace-0001")
            .withQuestGroupName("quest-group-0001")
            .withQuestName("quest-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

```

**Python**
```python

from gs2 import core
from gs2 import quest

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

try:
    result = client.delete_quest_model_master(
        quest.DeleteQuestModelMasterRequest()
            .with_namespace_name('namespace-0001')
            .with_quest_group_name('quest-group-0001')
            .with_quest_name('quest-0001')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)


```

**GS2-Script**
```lua

client = gs2('quest')

api_result = client.delete_quest_model_master({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-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('quest')

api_result_handler = client.delete_quest_model_master_async({
    namespaceName="namespace-0001",
    questGroupName="quest-group-0001",
    questName="quest-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;

```



---