> 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>

스크립트 실행 방식은 크게 두 가지로, 바로 "동기 실행"과 "비동기 실행"입니다.<br>
동기 실행은 스크립트 실행이 완료될 때까지 처리가 블록됩니다.<br>
대신 스크립트 실행 결과를 이용하여 API 실행을 중단시키거나 API 응답 내용을 제어할 수 있습니다.<br>

한편, 비동기 실행에서는 스크립트 완료를 기다리기 위해 처리가 블록되는 일이 없습니다.<br>
다만 스크립트 실행 결과를 이용하여 API 실행을 중단하거나 API 응답 내용을 변경할 수는 없습니다.<br>
비동기 실행은 API의 응답 흐름에 영향을 주지 않으므로 원칙적으로 비동기 실행을 권장합니다.<br>

비동기 실행에는 실행 방식이 두 가지 있으며, 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>이 클리어 완료 퀘스트 목록이 속한 퀘스트 그룹의 이름입니다. 사용자별·퀘스트 그룹별로 하나의 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>

퀘스트 그룹은 여러 퀘스트를 그룹화하기 위한 엔티티로, 퀘스트 진행은 그룹 내에서 동시에 하나만 실행할 수 있습니다.<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>이 퀘스트 그룹에 속한 퀘스트 모델의 목록입니다. 그룹 내에서는 동시에 하나의 퀘스트만 진행할 수 있습니다. |
| challengePeriodEventId | string |  |  |  |  ~ 1024자 | 도전 가능 기간 이벤트 GRN<br>이 그룹 내 퀘스트에 도전할 수 있는 기간을 설정하는 GS2-Schedule의 이벤트 GRN입니다. 지정한 경우, 이벤트가 활성화된 기간 동안에만 퀘스트를 시작할 수 있습니다. |

**관련 메서드:**
getProgress - 퀘스트 진행 상황 조회
getProgressByUserId - 사용자 ID를 지정하여 퀘스트 진행 상황 조회
describeQuestGroupModels - 퀘스트 그룹 모델 목록 조회
getQuestGroupModel - 퀘스트 그룹 모델 조회



---

### QuestModel

퀘스트 모델<br>

퀘스트 모델은 인게임 시작에 필요한 대가와 클리어했을 때 얻는 보상을 보유하는 엔티티입니다.<br>

클리어했을 때 얻는 보상은 여러 배리에이션을 준비할 수 있으며, 퀘스트 시작 시 추첨할 수 있습니다.<br>
예를 들어, 퀘스트 자체는 동일하더라도 레어 몬스터의 출현 여부에 따라 두 가지 콘텐츠 배리에이션을 만들 수 있습니다.


|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| 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>이 퀘스트의 콘텐츠 배리에이션 목록입니다. 퀘스트 시작 시 가중치 추첨을 통해 하나의 배리에이션이 선택됩니다. 각 배리에이션마다 서로 다른 클리어 보상을 정의할 수 있어, 동일한 퀘스트라도 다른 결과(예: 레어 몬스터의 출현)를 구현할 수 있습니다. |
| 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>

퀘스트 콘텐츠의 하나의 배리에이션을 나타냅니다. 각 퀘스트는 서로 다른 보상을 가진 여러 콘텐츠 배리에이션을 가질 수 있으며, 퀘스트 시작 시 가중치 추첨을 통해 하나가 선택됩니다. 메타데이터는 사용자 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 파일을 출력하는 방식으로도 서비스를 이용할 수 있습니다.
**ℹ️ Note**

JSON 파일 형식에 대해서는 [GS2-Quest 마스터 데이터 레퍼런스](api_reference/quest/master_data/)를 참조해 주세요.


|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string |  | ※ |  |  ~ 1024자 | 네임스페이스 GRN<br>※ 서버가 자동으로 설정 |
| settings | string |  | ✓ |  |  ~ 5242880 바이트 (5MB) | 마스터 데이터 |

**관련 메서드:**
exportMaster - 퀘스트 모델 마스터를 활성화 가능한 마스터 데이터 형식으로 내보내기
getCurrentQuestMaster - 현재 활성화된 퀘스트 모델의 마스터 데이터 조회
updateCurrentQuestMaster - 현재 활성화된 퀘스트 모델의 마스터 데이터 갱신
updateCurrentQuestMasterFromGitHub - 현재 활성화된 퀘스트 모델의 마스터 데이터를 GitHub에서 갱신



---

### QuestGroupModelMaster

퀘스트 그룹 모델 마스터<br>

퀘스트 그룹 모델 마스터는 게임 내에서 사용되는 퀘스트 그룹 모델의 편집·관리용 데이터로, 매니지먼트 콘솔의 마스터 데이터 에디터에서 일시적으로 보관됩니다.<br>
임포트·업데이트 처리를 수행함으로써 실제로 게임에서 참조되는 퀘스트 그룹 모델로 반영됩니다.<br>

퀘스트 그룹은 여러 퀘스트를 그룹화하기 위한 엔티티로, 퀘스트 진행은 그룹 내에서 동시에 하나만 실행할 수 있습니다.<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>
예를 들어 퀘스트 자체는 동일하더라도, 레어 몬스터의 출현 여부에 따라 두 종류의 콘텐츠 배리에이션을 만들 수 있습니다.


|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| 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>이 퀘스트의 콘텐츠 배리에이션 목록입니다. 퀘스트 시작 시 가중치 추첨을 통해 하나의 배리에이션이 선택됩니다. 각 배리에이션마다 서로 다른 클리어 보상을 정의할 수 있어, 동일한 퀘스트라도 다른 결과(예: 레어 몬스터의 출현)를 구현할 수 있습니다. |
| 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>

지정한 사용자의 퀘스트 진행 상황을 조회합니다. 사용자는 퀘스트 그룹마다 동시에 하나의 퀘스트 진행 상황만 보유할 수 있습니다.


#### 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>

같은 카테고리 내에서 게임 플레이어는 동시에 하나의 퀘스트만 실행할 수 있습니다.<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>

같은 카테고리 내에서 게임 플레이어는 동시에 하나의 퀘스트만 실행할 수 있습니다.<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>이 클리어 완료 퀘스트 목록이 속한 퀘스트 그룹의 이름입니다. 사용자별·퀘스트 그룹별로 하나의 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>이 클리어 완료 퀘스트 목록이 속한 퀘스트 그룹의 이름입니다. 사용자별·퀘스트 그룹별로 하나의 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>이 클리어 완료 퀘스트 목록이 속한 퀘스트 그룹의 이름입니다. 사용자별·퀘스트 그룹별로 하나의 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>

현재 활성화된 퀘스트 그룹 모델의 목록을 조회합니다. 퀘스트 그룹은 퀘스트를 정리하는 카테고리 역할을 하며, 사용자는 그룹별로 하나의 퀘스트만 진행할 수 있습니다.


#### 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>이 퀘스트의 콘텐츠 배리에이션 목록입니다. 퀘스트 시작 시 가중치 추첨을 통해 하나의 배리에이션이 선택됩니다. 각 배리에이션마다 서로 다른 클리어 보상을 정의할 수 있어, 동일한 퀘스트라도 다른 결과(예: 레어 몬스터의 출현)를 구현할 수 있습니다. |
| 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>이 퀘스트의 콘텐츠 배리에이션 목록입니다. 퀘스트 시작 시 가중치 추첨을 통해 하나의 배리에이션이 선택됩니다. 각 배리에이션마다 서로 다른 클리어 보상을 정의할 수 있어, 동일한 퀘스트라도 다른 결과(예: 레어 몬스터의 출현)를 구현할 수 있습니다. |
| 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;

```



---