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

# GS2-Quest Deploy/CDK リファレンス

GS2-Deployのスタックを作成する際に使用するテンプレートのフォーマットと、CDKによる各種言語のテンプレート出力の実装例




## エンティティ

Deploy処理で操作の対象となるリソース

### Namespace

ネームスペース<br>

ネームスペースは、一つのプロジェクト内で同じサービスを異なる用途で複数利用するためのエンティティです。<br>
GS2 の各サービスはネームスペース単位で管理されます。ネームスペースが異なれば、同じサービスでも完全に独立したデータ空間として扱われます。<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 のネームスペースを指定します。クエストの開始・クリア・失敗イベントの追跡に使用されます。 |

#### GetAttr

[!GetAttr](/articles/tech/deploy/#getattr)タグで取得可能なリソースの生成結果

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

#### 実装例




**GS2-Deploy(YAML)**
```yaml

Type: GS2::Quest::Namespace
Properties:
  Name: namespace-0001
  Description: null
  TransactionSetting: 
    EnableAutoRun: true
    QueueNamespaceId: grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001
  StartQuestScript: null
  CompleteQuestScript: null
  FailedQuestScript: null
  LogSetting: 
    LoggingNamespaceId: grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001

```

**Go**
```go

import (
    "github.com/gs2io/gs2-golang-cdk/core"
    "github.com/gs2io/gs2-golang-cdk/quest"
    "github.com/openlyinc/pointy"
)


SampleStack := core.NewStack()
quest.NewNamespace(
    &SampleStack,
    "namespace-0001",
    quest.NamespaceOptions{
        TransactionSetting: core.NewTransactionSetting(
            core.TransactionSettingOptions{
                QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
            },
        ),
        LogSetting: &core.LogSetting{
            LoggingNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
        },
    },
)

println(SampleStack.Yaml())  // Generate Template

```

**PHP**
```php

class SampleStack extends \Gs2Cdk\Core\Model\Stack
{
    function __construct() {
        parent::__construct();
        new \Gs2Cdk\Quest\Model\Namespace_(
            stack: $this,
            name: "namespace-0001",
            options: new \Gs2Cdk\Quest\Model\Options\NamespaceOptions(
                transactionSetting: new \Gs2Cdk\Core\Model\TransactionSetting(
                    new \Gs2Cdk\Core\Model\TransactionSettingOptions(
                        queueNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"
                    )
                ),
                logSetting: new \Gs2Cdk\Core\Model\LogSetting(
                    loggingNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                )
            )
        );
    }
}

print((new SampleStack())->yaml());  // Generate Template

```

**Java**
```java

class SampleStack extends io.gs2.cdk.core.model.Stack
{
    public SampleStack() {
        super();
        new io.gs2.cdk.quest.model.Namespace(
                this,
                "namespace-0001",
                new io.gs2.cdk.quest.model.options.NamespaceOptions()
                        .withTransactionSetting(new io.gs2.cdk.core.model.TransactionSetting(
                            new io.gs2.cdk.core.model.options.TransactionSettingOptions()
                                .withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001")
                        ))
                        .withLogSetting(new io.gs2.cdk.core.model.LogSetting(
                            "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                        ))
        );
    }
}

System.out.println(new SampleStack().yaml());  // Generate Template

```

**C#**
```csharp

public class SampleStack : Gs2Cdk.Core.Model.Stack
{
    public SampleStack() {
        new Gs2Cdk.Gs2Quest.Model.Namespace(
            stack: this,
            name: "namespace-0001",
            options: new Gs2Cdk.Gs2Quest.Model.Options.NamespaceOptions
            {
                transactionSetting = new Gs2Cdk.Core.Model.TransactionSetting(
                    options: new Gs2Cdk.Core.Model.TransactionSettingOptions
                    {
                        queueNamespaceId = "grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"
                    }
                ),
                logSetting = new Gs2Cdk.Core.Model.LogSetting(
                    loggingNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                )
            }
        );
    }
}

Debug.Log(new SampleStack().Yaml());  // Generate Template

```

**TypeScript**
```typescript

import core from "@/gs2cdk/core";
import quest from "@/gs2cdk/quest";

class SampleStack extends core.Stack
{
    public constructor() {
        super();
        new quest.model.Namespace(
            this,
            "namespace-0001",
            {
                transactionSetting: new core.TransactionSetting(
                    {
                        queueNamespaceId: "grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"
                    }
                ),
                logSetting: new core.LogSetting(
                    "grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"
                )
            }
        );
    }
}

console.log(new SampleStack().yaml());  // Generate Template

```

**Python**
```python

from gs2_cdk import Stack, core, quest

class SampleStack(Stack):

    def __init__(self):
        super().__init__()
        quest.Namespace(
            stack=self,
            name='namespace-0001',
            options=quest.NamespaceOptions(
                transaction_setting=core.TransactionSetting(
                    options=core.TransactionSettingOptions(
                        queue_namespace_id='grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001',
                    )
                ),
                log_setting=core.LogSetting(
                    logging_namespace_id='grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001',
                ),
            ),
        )

print(SampleStack().yaml())  # Generate Template

```


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

#### ScriptSetting

スクリプト設定<br>

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

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

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

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

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

#### 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で指定する必要があります。 |

---

### CurrentQuestMaster

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

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

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

#### Request

リソースの生成・更新リクエスト

|  | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128文字 | ネームスペース名<br>ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| mode | 文字列列挙型<br>enum {<br>&nbsp;&nbsp;"direct",<br>&nbsp;&nbsp;"preUpload"<br>}<br> |  | | "direct" |  | 更新モード"direct": マスターデータを直接更新 / "preUpload": マスターデータをアップロードしてから更新 /  |
| settings | string | {mode} == "direct" | ✓※|  |  ~ 5242880 バイト (5MB) | マスターデータ<br>※ mode が "direct" であれば必須 |
| uploadToken | string | {mode} == "preUpload" | ✓※|  |  ~ 1024文字 | 事前アップロードで取得したトークン<br>アップロードしたマスターデータを適用するために使用されます。<br>※ mode が "preUpload" であれば必須 |

#### GetAttr

[!GetAttr](/articles/tech/deploy/#getattr)タグで取得可能なリソースの生成結果

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

#### 実装例




**GS2-Deploy(YAML)**
```yaml

Type: GS2::Quest::CurrentQuestMaster
Properties:
  NamespaceName: namespace-0001
  Mode: direct
  Settings: {
    "version": "2019-05-14",
    "groups": [
      {
        "name": "main",
        "metadata": "MAIN",
        "quests": [
          {
            "name": "1-1",
            "metadata": "stage1-1",
            "contents": [
              {
                "metadata": "normal",
                "completeAcquireActions": [
                  {
                    "action": "Gs2Experience:AddExperienceByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "experienceName": "player",
                      "propertyId": "player",
                      "experienceValue": 30,
                      "truncateExperienceWhenRankUp": false,
                      "userId": "#{userId}"
                    }
                  },
                  {
                    "action": "Gs2Inventory:AcquireItemSetByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "inventoryName": "inventory-0001",
                      "itemName": "item-0001",
                      "acquireCount": 1,
                      "expiresAt": 0,
                      "createNewItemSet": false,
                      "itemSetName": "",
                      "userId": "#{userId}"
                    }
                  }
                ],
                "weight": 99
              },
              {
                "metadata": "rare",
                "completeAcquireActions": [
                  {
                    "action": "Gs2Experience:AddExperienceByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "experienceName": "player",
                      "propertyId": "player",
                      "experienceValue": 30,
                      "truncateExperienceWhenRankUp": false,
                      "userId": "#{userId}"
                    }
                  },
                  {
                    "action": "Gs2Inventory:AcquireItemSetByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "inventoryName": "inventory-0001",
                      "itemName": "item-0001",
                      "acquireCount": 1,
                      "expiresAt": 0,
                      "createNewItemSet": false,
                      "itemSetName": "",
                      "userId": "#{userId}"
                    }
                  }
                ],
                "weight": 1
              }
            ],
            "consumeActions": [
              {
                "action": "Gs2Stamina:ConsumeStaminaByUserId",
                "request": {
                  "namespaceName": "basic",
                  "staminaName": "quest",
                  "userId": "#{userId}",
                  "consumeValue": 5
                }
              }
            ],
            "failedAcquireActions": [
              {
                "action": "Gs2Stamina:RecoverStaminaByUserId",
                "request": {
                  "namespaceName": "basic",
                  "staminaName": "quest",
                  "userId": "#{userId}",
                  "recoverValue": 5
                }
              }
            ],
            "premiseQuestNames": [
              ]
          },
          {
            "name": "1-2",
            "metadata": "stage1-2",
            "contents": [
              {
                "metadata": "normal",
                "completeAcquireActions": [
                  {
                    "action": "Gs2Experience:AddExperienceByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "experienceName": "player",
                      "propertyId": "player",
                      "experienceValue": 30,
                      "truncateExperienceWhenRankUp": false,
                      "userId": "#{userId}"
                    }
                  },
                  {
                    "action": "Gs2Inventory:AcquireItemSetByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "inventoryName": "inventory-0001",
                      "itemName": "item-0001",
                      "acquireCount": 1,
                      "expiresAt": 0,
                      "createNewItemSet": false,
                      "itemSetName": "",
                      "userId": "#{userId}"
                    }
                  }
                ],
                "weight": 98
              },
              {
                "metadata": "rare",
                "completeAcquireActions": [
                  {
                    "action": "Gs2Experience:AddExperienceByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "experienceName": "player",
                      "propertyId": "player",
                      "experienceValue": 30,
                      "truncateExperienceWhenRankUp": false,
                      "userId": "#{userId}"
                    }
                  },
                  {
                    "action": "Gs2Inventory:AcquireItemSetByUserId",
                    "request": {
                      "namespaceName": "namespace-0001",
                      "inventoryName": "inventory-0001",
                      "itemName": "item-0001",
                      "acquireCount": 1,
                      "expiresAt": 0,
                      "createNewItemSet": false,
                      "itemSetName": "",
                      "userId": "#{userId}"
                    }
                  }
                ],
                "weight": 2
              }
            ],
            "consumeActions": [
              {
                "action": "Gs2Stamina:ConsumeStaminaByUserId",
                "request": {
                  "namespaceName": "basic",
                  "staminaName": "quest",
                  "consumeValue": 5,
                  "userId": "#{userId}"
                }
              }
            ],
            "failedAcquireActions": [
              {
                "action": "Gs2Stamina:RecoverStaminaByUserId",
                "request": {
                  "namespaceName": "basic",
                  "staminaName": "quest",
                  "userId": "#{userId}",
                  "recoverValue": 5
                }
              }
            ],
            "premiseQuestNames": [
              "1-1"
            ]
          }
        ]
      },
      {
        "name": "sub",
        "metadata": "SUB",
        "quests": [
          {
            "name": "1-1",
            "metadata": "stage1-1",
            "contents": [
              {
                "metadata": "normal",
                "completeAcquireActions": [
                  {
                    "action": "Gs2JobQueue:PushByUserId",
                    "request": {
                      "namespaceName": "queue-0001",
                      "userId": "#{userId}",
                      "jobs": [{'scriptId': 'script-0001', 'args': {}, 'maxTryCount': 3}]
                    }
                  }
                ],
                "weight": 1
              }
            ],
            "premiseQuestNames": [
              ]
          }
        ]
      }
    ]
  }
  UploadToken: null

```

**Go**
```go

import (
    "github.com/gs2io/gs2-golang-cdk/core"
    "github.com/gs2io/gs2-golang-cdk/quest"
    "github.com/gs2io/gs2-golang-cdk/experience"
    "github.com/gs2io/gs2-golang-cdk/inventory"
    "github.com/gs2io/gs2-golang-cdk/stamina"
    "github.com/openlyinc/pointy"
)


SampleStack := core.NewStack()
quest.NewNamespace(
    &SampleStack,
    "namespace-0001",
    quest.NamespaceOptions{},
).MasterData(
    []quest.QuestGroupModel{
        quest.NewQuestGroupModel(
            "main",
            quest.QuestGroupModelOptions{
                Metadata: pointy.String("MAIN"),
                Quests: []quest.QuestModel{
                    quest.NewQuestModel(
                        "1-1",
                        []quest.Contents{
                            quest.NewContents(
                                99,
                                quest.ContentsOptions{
                                    Metadata: pointy.String("normal"),
                                    CompleteAcquireActions: []core.AcquireAction{
                                        experience.AddExperienceByUserId(
                                            "namespace-0001",
                                            "player",
                                            "player",
                                            pointy.Int64(30),
                                            pointy.Bool(false),
                                        ),
                                        inventory.AcquireItemSetByUserId(
                                            "namespace-0001",
                                            "inventory-0001",
                                            "item-0001",
                                            1,
                                            pointy.Int64(0),
                                            pointy.Bool(false),
                                            pointy.String(""),
                                        ),
                                    },
                                },
                            ),
                            quest.NewContents(
                                1,
                                quest.ContentsOptions{
                                    Metadata: pointy.String("rare"),
                                    CompleteAcquireActions: []core.AcquireAction{
                                        experience.AddExperienceByUserId(
                                            "namespace-0001",
                                            "player",
                                            "player",
                                            pointy.Int64(30),
                                            pointy.Bool(false),
                                        ),
                                        inventory.AcquireItemSetByUserId(
                                            "namespace-0001",
                                            "inventory-0001",
                                            "item-0001",
                                            1,
                                            pointy.Int64(0),
                                            pointy.Bool(false),
                                            pointy.String(""),
                                        ),
                                    },
                                },
                            ),
                        },
                        quest.QuestModelOptions{
                            Metadata: pointy.String("stage1-1"),
                            ConsumeActions: []core.ConsumeAction{
                                stamina.ConsumeStaminaByUserId(
                                    "namespace-0001",
                                    "quest",
                                    5,
                                ),
                            },
                            FailedAcquireActions: []core.AcquireAction{
                                stamina.RecoverStaminaByUserId(
                                    "namespace-0001",
                                    "quest",
                                    5,
                                ),
                            },
                            PremiseQuestNames: []string{},
                        },
                    ),
                    quest.NewQuestModel(
                        "1-2",
                        []quest.Contents{
                            quest.NewContents(
                                98,
                                quest.ContentsOptions{
                                    Metadata: pointy.String("normal"),
                                    CompleteAcquireActions: []core.AcquireAction{
                                        experience.AddExperienceByUserId(
                                            "namespace-0001",
                                            "player",
                                            "player",
                                            pointy.Int64(30),
                                            pointy.Bool(false),
                                        ),
                                        inventory.AcquireItemSetByUserId(
                                            "namespace-0001",
                                            "inventory-0001",
                                            "item-0001",
                                            1,
                                            pointy.Int64(0),
                                            pointy.Bool(false),
                                            pointy.String(""),
                                        ),
                                    },
                                },
                            ),
                            quest.NewContents(
                                2,
                                quest.ContentsOptions{
                                    Metadata: pointy.String("rare"),
                                    CompleteAcquireActions: []core.AcquireAction{
                                        experience.AddExperienceByUserId(
                                            "namespace-0001",
                                            "player",
                                            "player",
                                            pointy.Int64(30),
                                            pointy.Bool(false),
                                        ),
                                        inventory.AcquireItemSetByUserId(
                                            "namespace-0001",
                                            "inventory-0001",
                                            "item-0001",
                                            1,
                                            pointy.Int64(0),
                                            pointy.Bool(false),
                                            pointy.String(""),
                                        ),
                                    },
                                },
                            ),
                        },
                        quest.QuestModelOptions{
                            Metadata: pointy.String("stage1-2"),
                            ConsumeActions: []core.ConsumeAction{
                                stamina.ConsumeStaminaByUserId(
                                    "namespace-0001",
                                    "quest",
                                    5,
                                ),
                            },
                            FailedAcquireActions: []core.AcquireAction{
                                stamina.RecoverStaminaByUserId(
                                    "namespace-0001",
                                    "quest",
                                    5,
                                ),
                            },
                            PremiseQuestNames: []string{
                                "1-1",
                            },
                        },
                    ),
                },
            },
        ),
        quest.NewQuestGroupModel(
            "sub",
            quest.QuestGroupModelOptions{
                Metadata: pointy.String("SUB"),
                Quests: []quest.QuestModel{
                    quest.NewQuestModel(
                        "1-1",
                        []quest.Contents{
                            quest.NewContents(
                                1,
                                quest.ContentsOptions{
                                    Metadata: pointy.String("normal"),
                                    CompleteAcquireActions: []core.AcquireAction{
                                        jobQueue.PushByUserId(
                                            "queue-0001",
                                            &[]jobQueue.JobEntry{ jobQueue.NewJobEntry("script-0001", "", 3, jobQueue.JobEntryOptions{},), },
                                        ),
                                    },
                                },
                            ),
                        },
                        quest.QuestModelOptions{
                            Metadata: pointy.String("stage1-1"),
                            PremiseQuestNames: []string{},
                        },
                    ),
                },
            },
        ),
    },
)

println(SampleStack.Yaml())  // Generate Template

```

**PHP**
```php

class SampleStack extends \Gs2Cdk\Core\Model\Stack
{
    function __construct() {
        parent::__construct();
        (new \Gs2Cdk\Quest\Model\Namespace_(
            stack: $this,
            name: "namespace-0001"
        ))->masterData(
            [
                new \Gs2Cdk\Quest\Model\QuestGroupModel(
                    name:"main",
                    options: new \Gs2Cdk\Quest\Model\Options\QuestGroupModelOptions(
                        metadata:"MAIN",
                        quests:[
                            new \Gs2Cdk\Quest\Model\QuestModel(
                                name: "1-1",
                                contents: [
                                    new \Gs2Cdk\Quest\Model\Contents(
                                        weight: 99,
                                        options: new \Gs2Cdk\Quest\Model\Options\ContentsOptions(
                                            metadata: "normal",
                                            completeAcquireActions: [
                                                new \Gs2Cdk\Experience\StampSheet\AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new \Gs2Cdk\Inventory\StampSheet\AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                ),
                                            ],
                                        ),
                                    ),
                                    new \Gs2Cdk\Quest\Model\Contents(
                                        weight: 1,
                                        options: new \Gs2Cdk\Quest\Model\Options\ContentsOptions(
                                            metadata: "rare",
                                            completeAcquireActions: [
                                                new \Gs2Cdk\Experience\StampSheet\AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new \Gs2Cdk\Inventory\StampSheet\AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                ),
                                            ],
                                        ),
                                    ),
                                ],
                                options: new \Gs2Cdk\Quest\Model\Options\QuestModelOptions(
                                    metadata: "stage1-1",
                                    consumeActions: [
                                        new \Gs2Cdk\Stamina\StampSheet\ConsumeStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            userId: "#{userId}",
                                            consumeValue: 5
                                        ),
                                    ],
                                    failedAcquireActions: [
                                        new \Gs2Cdk\Stamina\StampSheet\RecoverStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            userId: "#{userId}",
                                            recoverValue: 5
                                        ),
                                    ],
                                    premiseQuestNames: [],
                                ),
                            ),
                            new \Gs2Cdk\Quest\Model\QuestModel(
                                name: "1-2",
                                contents: [
                                    new \Gs2Cdk\Quest\Model\Contents(
                                        weight: 98,
                                        options: new \Gs2Cdk\Quest\Model\Options\ContentsOptions(
                                            metadata: "normal",
                                            completeAcquireActions: [
                                                new \Gs2Cdk\Experience\StampSheet\AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new \Gs2Cdk\Inventory\StampSheet\AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                ),
                                            ],
                                        ),
                                    ),
                                    new \Gs2Cdk\Quest\Model\Contents(
                                        weight: 2,
                                        options: new \Gs2Cdk\Quest\Model\Options\ContentsOptions(
                                            metadata: "rare",
                                            completeAcquireActions: [
                                                new \Gs2Cdk\Experience\StampSheet\AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new \Gs2Cdk\Inventory\StampSheet\AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                ),
                                            ],
                                        ),
                                    ),
                                ],
                                options: new \Gs2Cdk\Quest\Model\Options\QuestModelOptions(
                                    metadata: "stage1-2",
                                    consumeActions: [
                                        new \Gs2Cdk\Stamina\StampSheet\ConsumeStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            consumeValue: 5,
                                            userId: "#{userId}"
                                        ),
                                    ],
                                    failedAcquireActions: [
                                        new \Gs2Cdk\Stamina\StampSheet\RecoverStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            userId: "#{userId}",
                                            recoverValue: 5
                                        ),
                                    ],
                                    premiseQuestNames: [
                                        "1-1",
                                    ],
                                ),
                            ),
                        ]
                    )
                ),
                new \Gs2Cdk\Quest\Model\QuestGroupModel(
                    name:"sub",
                    options: new \Gs2Cdk\Quest\Model\Options\QuestGroupModelOptions(
                        metadata:"SUB",
                        quests:[
                            new \Gs2Cdk\Quest\Model\QuestModel(
                                name: "1-1",
                                contents: [
                                    new \Gs2Cdk\Quest\Model\Contents(
                                        weight: 1,
                                        options: new \Gs2Cdk\Quest\Model\Options\ContentsOptions(
                                            metadata: "normal",
                                            completeAcquireActions: [
                                                new \Gs2Cdk\JobQueue\StampSheet\PushByUserId(
                                                    namespaceName: "queue-0001",
                                                    jobs: [ new \Gs2Cdk\JobQueue\Model\JobEntry(scriptId: "script-0001", args: "", maxTryCount: 3)],
                                                    userId: "#{userId}"
                                                ),
                                            ],
                                        ),
                                    ),
                                ],
                                options: new \Gs2Cdk\Quest\Model\Options\QuestModelOptions(
                                    metadata: "stage1-1",
                                    premiseQuestNames: [],
                                ),
                            ),
                        ]
                    )
                )
            ]
        );
    }
}

print((new SampleStack())->yaml());  // Generate Template

```

**Java**
```java

class SampleStack extends io.gs2.cdk.core.model.Stack
{
    public SampleStack() {
        super();
        new io.gs2.cdk.quest.model.Namespace(
            this,
            "namespace-0001"
        ).masterData(
            Arrays.asList(
                new io.gs2.cdk.quest.model.QuestGroupModel(
                    "main",
                    new io.gs2.cdk.quest.model.options.QuestGroupModelOptions()
                        .withMetadata("MAIN")
                        .withQuests(Arrays.asList(
                            new io.gs2.cdk.quest.model.QuestModel(
                                "1-1",
                                Arrays.asList(
                                    new io.gs2.cdk.quest.model.Contents(
                                        99,
                                        new io.gs2.cdk.quest.model.options.ContentsOptions()
                                            .withMetadata("normal")
                                            .withCompleteAcquireActions(Arrays.asList(
                                                new io.gs2.cdk.experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30L,
                                                    false,
                                                    "#{userId}"
                                                ),
                                                new io.gs2.cdk.inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1L,
                                                    0L,
                                                    false,
                                                    "",
                                                    "#{userId}"
                                                )
                                            ))
                                    ),
                                    new io.gs2.cdk.quest.model.Contents(
                                        1,
                                        new io.gs2.cdk.quest.model.options.ContentsOptions()
                                            .withMetadata("rare")
                                            .withCompleteAcquireActions(Arrays.asList(
                                                new io.gs2.cdk.experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30L,
                                                    false,
                                                    "#{userId}"
                                                ),
                                                new io.gs2.cdk.inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1L,
                                                    0L,
                                                    false,
                                                    "",
                                                    "#{userId}"
                                                )
                                            ))
                                    )
                                ),
                                new io.gs2.cdk.quest.model.options.QuestModelOptions()
                                    .withMetadata("stage1-1")
                                    .withConsumeActions(Arrays.asList(
                                        new io.gs2.cdk.stamina.stampSheet.ConsumeStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            "#{userId}"
                                        )
                                    ))
                                    .withFailedAcquireActions(Arrays.asList(
                                        new io.gs2.cdk.stamina.stampSheet.RecoverStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            "#{userId}"
                                        )
                                    ))
                                    .withPremiseQuestNames(new ArrayList<String>())
                            ),
                            new io.gs2.cdk.quest.model.QuestModel(
                                "1-2",
                                Arrays.asList(
                                    new io.gs2.cdk.quest.model.Contents(
                                        98,
                                        new io.gs2.cdk.quest.model.options.ContentsOptions()
                                            .withMetadata("normal")
                                            .withCompleteAcquireActions(Arrays.asList(
                                                new io.gs2.cdk.experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30L,
                                                    false,
                                                    "#{userId}"
                                                ),
                                                new io.gs2.cdk.inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1L,
                                                    0L,
                                                    false,
                                                    "",
                                                    "#{userId}"
                                                )
                                            ))
                                    ),
                                    new io.gs2.cdk.quest.model.Contents(
                                        2,
                                        new io.gs2.cdk.quest.model.options.ContentsOptions()
                                            .withMetadata("rare")
                                            .withCompleteAcquireActions(Arrays.asList(
                                                new io.gs2.cdk.experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30L,
                                                    false,
                                                    "#{userId}"
                                                ),
                                                new io.gs2.cdk.inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1L,
                                                    0L,
                                                    false,
                                                    "",
                                                    "#{userId}"
                                                )
                                            ))
                                    )
                                ),
                                new io.gs2.cdk.quest.model.options.QuestModelOptions()
                                    .withMetadata("stage1-2")
                                    .withConsumeActions(Arrays.asList(
                                        new io.gs2.cdk.stamina.stampSheet.ConsumeStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            "#{userId}"
                                        )
                                    ))
                                    .withFailedAcquireActions(Arrays.asList(
                                        new io.gs2.cdk.stamina.stampSheet.RecoverStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            "#{userId}"
                                        )
                                    ))
                                    .withPremiseQuestNames(Arrays.asList(
                                        "1-1"
                                    ))
                            )
                        ))
                ),
                new io.gs2.cdk.quest.model.QuestGroupModel(
                    "sub",
                    new io.gs2.cdk.quest.model.options.QuestGroupModelOptions()
                        .withMetadata("SUB")
                        .withQuests(Arrays.asList(
                            new io.gs2.cdk.quest.model.QuestModel(
                                "1-1",
                                Arrays.asList(
                                    new io.gs2.cdk.quest.model.Contents(
                                        1,
                                        new io.gs2.cdk.quest.model.options.ContentsOptions()
                                            .withMetadata("normal")
                                            .withCompleteAcquireActions(Arrays.asList(
                                                new io.gs2.cdk.jobQueue.stampSheet.PushByUserId(
                                                    "queue-0001",
                                                    Arrays.asList(new io.gs2.cdk.jobQueue.model.JobEntry("script-0001", "", 3)),
                                                    "#{userId}"
                                                )
                                            ))
                                    )
                                ),
                                new io.gs2.cdk.quest.model.options.QuestModelOptions()
                                    .withMetadata("stage1-1")
                                    .withPremiseQuestNames(new ArrayList<String>())
                            )
                        ))
                )
            )
        );
    }
}

System.out.println(new SampleStack().yaml());  // Generate Template

```

**C#**
```csharp

public class SampleStack : Gs2Cdk.Core.Model.Stack
{
    public SampleStack() {
        new Gs2Cdk.Gs2Quest.Model.Namespace(
            stack: this,
            name: "namespace-0001"
        ).MasterData(
            new Gs2Cdk.Gs2Quest.Model.QuestGroupModel[] {
                new Gs2Cdk.Gs2Quest.Model.QuestGroupModel(
                    name: "main",
                    options: new Gs2Cdk.Gs2Quest.Model.Options.QuestGroupModelOptions
                    {
                        metadata = "MAIN",
                        quests = new Gs2Cdk.Gs2Quest.Model.QuestModel[]
                        {
                            new Gs2Cdk.Gs2Quest.Model.QuestModel(
                                name: "1-1",
                                contents: new Gs2Cdk.Gs2Quest.Model.Contents[]
                                {
                                    new Gs2Cdk.Gs2Quest.Model.Contents(
                                        weight: 99,
                                        options: new Gs2Cdk.Gs2Quest.Model.Options.ContentsOptions
                                        {
                                            metadata = "normal",
                                            completeAcquireActions = new Gs2Cdk.Core.Model.AcquireAction[]
                                            {
                                                new Gs2Cdk.Gs2Experience.StampSheet.AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new Gs2Cdk.Gs2Inventory.StampSheet.AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                )
                                            }
                                        }
                                    ),
                                    new Gs2Cdk.Gs2Quest.Model.Contents(
                                        weight: 1,
                                        options: new Gs2Cdk.Gs2Quest.Model.Options.ContentsOptions
                                        {
                                            metadata = "rare",
                                            completeAcquireActions = new Gs2Cdk.Core.Model.AcquireAction[]
                                            {
                                                new Gs2Cdk.Gs2Experience.StampSheet.AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new Gs2Cdk.Gs2Inventory.StampSheet.AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                )
                                            }
                                        }
                                    )
                                },
                                options: new Gs2Cdk.Gs2Quest.Model.Options.QuestModelOptions
                                {
                                    metadata = "stage1-1",
                                    consumeActions = new Gs2Cdk.Core.Model.ConsumeAction[]
                                    {
                                        new Gs2Cdk.Gs2Stamina.StampSheet.ConsumeStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            userId: "#{userId}",
                                            consumeValue: 5
                                        )
                                    },
                                    failedAcquireActions = new Gs2Cdk.Core.Model.AcquireAction[]
                                    {
                                        new Gs2Cdk.Gs2Stamina.StampSheet.RecoverStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            userId: "#{userId}",
                                            recoverValue: 5
                                        )
                                    },
                                    premiseQuestNames = new string[] {}
                                }
                            ),
                            new Gs2Cdk.Gs2Quest.Model.QuestModel(
                                name: "1-2",
                                contents: new Gs2Cdk.Gs2Quest.Model.Contents[]
                                {
                                    new Gs2Cdk.Gs2Quest.Model.Contents(
                                        weight: 98,
                                        options: new Gs2Cdk.Gs2Quest.Model.Options.ContentsOptions
                                        {
                                            metadata = "normal",
                                            completeAcquireActions = new Gs2Cdk.Core.Model.AcquireAction[]
                                            {
                                                new Gs2Cdk.Gs2Experience.StampSheet.AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new Gs2Cdk.Gs2Inventory.StampSheet.AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                )
                                            }
                                        }
                                    ),
                                    new Gs2Cdk.Gs2Quest.Model.Contents(
                                        weight: 2,
                                        options: new Gs2Cdk.Gs2Quest.Model.Options.ContentsOptions
                                        {
                                            metadata = "rare",
                                            completeAcquireActions = new Gs2Cdk.Core.Model.AcquireAction[]
                                            {
                                                new Gs2Cdk.Gs2Experience.StampSheet.AddExperienceByUserId(
                                                    namespaceName: "namespace-0001",
                                                    experienceName: "player",
                                                    propertyId: "player",
                                                    experienceValue: 30,
                                                    truncateExperienceWhenRankUp: false,
                                                    userId: "#{userId}"
                                                ),
                                                new Gs2Cdk.Gs2Inventory.StampSheet.AcquireItemSetByUserId(
                                                    namespaceName: "namespace-0001",
                                                    inventoryName: "inventory-0001",
                                                    itemName: "item-0001",
                                                    acquireCount: 1,
                                                    expiresAt: 0,
                                                    createNewItemSet: false,
                                                    itemSetName: "",
                                                    userId: "#{userId}"
                                                )
                                            }
                                        }
                                    )
                                },
                                options: new Gs2Cdk.Gs2Quest.Model.Options.QuestModelOptions
                                {
                                    metadata = "stage1-2",
                                    consumeActions = new Gs2Cdk.Core.Model.ConsumeAction[]
                                    {
                                        new Gs2Cdk.Gs2Stamina.StampSheet.ConsumeStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            consumeValue: 5,
                                            userId: "#{userId}"
                                        )
                                    },
                                    failedAcquireActions = new Gs2Cdk.Core.Model.AcquireAction[]
                                    {
                                        new Gs2Cdk.Gs2Stamina.StampSheet.RecoverStaminaByUserId(
                                            namespaceName: "basic",
                                            staminaName: "quest",
                                            userId: "#{userId}",
                                            recoverValue: 5
                                        )
                                    },
                                    premiseQuestNames = new string[]
                                    {
                                        "1-1"
                                    }
                                }
                            )
                        }
                    }
                ),
                new Gs2Cdk.Gs2Quest.Model.QuestGroupModel(
                    name: "sub",
                    options: new Gs2Cdk.Gs2Quest.Model.Options.QuestGroupModelOptions
                    {
                        metadata = "SUB",
                        quests = new Gs2Cdk.Gs2Quest.Model.QuestModel[]
                        {
                            new Gs2Cdk.Gs2Quest.Model.QuestModel(
                                name: "1-1",
                                contents: new Gs2Cdk.Gs2Quest.Model.Contents[]
                                {
                                    new Gs2Cdk.Gs2Quest.Model.Contents(
                                        weight: 1,
                                        options: new Gs2Cdk.Gs2Quest.Model.Options.ContentsOptions
                                        {
                                            metadata = "normal",
                                            completeAcquireActions = new Gs2Cdk.Core.Model.AcquireAction[]
                                            {
                                                new Gs2Cdk.Gs2JobQueue.StampSheet.PushByUserId(
                                                    namespaceName: "queue-0001",
                                                    jobs: new [] { new Gs2Cdk.Gs2JobQueue.Model.JobEntry(scriptId: "script-0001", args: "", maxTryCount: 3) },
                                                    userId: "#{userId}"
                                                )
                                            }
                                        }
                                    )
                                },
                                options: new Gs2Cdk.Gs2Quest.Model.Options.QuestModelOptions
                                {
                                    metadata = "stage1-1",
                                    premiseQuestNames = new string[] {}
                                }
                            )
                        }
                    }
                )
            }
        );
    }
}

Debug.Log(new SampleStack().Yaml());  // Generate Template

```

**TypeScript**
```typescript

import core from "@/gs2cdk/core";
import quest from "@/gs2cdk/quest";

class SampleStack extends core.Stack
{
    public constructor() {
        super();
        new quest.model.Namespace(
            this,
            "namespace-0001",
        ).masterData(
            [
                new quest.model.QuestGroupModel(
                    "main",
                    {
                        metadata: "MAIN",
                        quests: [
                            new quest.model.QuestModel(
                                "1-1",
                                [
                                    new quest.model.Contents(
                                        99,
                                        {
                                            metadata: "normal",
                                            completeAcquireActions: [
                                                new experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30,
                                                    false,
                                                    null,
                                                    "#{userId}"
                                                ),
                                                new inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1,
                                                    0,
                                                    false,
                                                    "",
                                                    null,
                                                    "#{userId}"
                                                ),
                                            ]
                                        }
                                    ),
                                    new quest.model.Contents(
                                        1,
                                        {
                                            metadata: "rare",
                                            completeAcquireActions: [
                                                new experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30,
                                                    false,
                                                    null,
                                                    "#{userId}"
                                                ),
                                                new inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1,
                                                    0,
                                                    false,
                                                    "",
                                                    null,
                                                    "#{userId}"
                                                ),
                                            ]
                                        }
                                    ),
                                ],
                                {
                                    metadata: "stage1-1",
                                    consumeActions: [
                                        new stamina.stampSheet.ConsumeStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            null,
                                            "#{userId}"
                                        ),
                                    ],
                                    failedAcquireActions: [
                                        new stamina.stampSheet.RecoverStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            null,
                                            "#{userId}"
                                        ),
                                    ],
                                    premiseQuestNames: []
                                }
                            ),
                            new quest.model.QuestModel(
                                "1-2",
                                [
                                    new quest.model.Contents(
                                        98,
                                        {
                                            metadata: "normal",
                                            completeAcquireActions: [
                                                new experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30,
                                                    false,
                                                    null,
                                                    "#{userId}"
                                                ),
                                                new inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1,
                                                    0,
                                                    false,
                                                    "",
                                                    null,
                                                    "#{userId}"
                                                ),
                                            ]
                                        }
                                    ),
                                    new quest.model.Contents(
                                        2,
                                        {
                                            metadata: "rare",
                                            completeAcquireActions: [
                                                new experience.stampSheet.AddExperienceByUserId(
                                                    "namespace-0001",
                                                    "player",
                                                    "player",
                                                    30,
                                                    false,
                                                    null,
                                                    "#{userId}"
                                                ),
                                                new inventory.stampSheet.AcquireItemSetByUserId(
                                                    "namespace-0001",
                                                    "inventory-0001",
                                                    "item-0001",
                                                    1,
                                                    0,
                                                    false,
                                                    "",
                                                    null,
                                                    "#{userId}"
                                                ),
                                            ]
                                        }
                                    ),
                                ],
                                {
                                    metadata: "stage1-2",
                                    consumeActions: [
                                        new stamina.stampSheet.ConsumeStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            null,
                                            "#{userId}"
                                        ),
                                    ],
                                    failedAcquireActions: [
                                        new stamina.stampSheet.RecoverStaminaByUserId(
                                            "namespace-0001",
                                            "quest",
                                            5,
                                            null,
                                            "#{userId}"
                                        ),
                                    ],
                                    premiseQuestNames: [
                                        "1-1",
                                    ]
                                }
                            ),
                        ]
                    }
                ),
                new quest.model.QuestGroupModel(
                    "sub",
                    {
                        metadata: "SUB",
                        quests: [
                            new quest.model.QuestModel(
                                "1-1",
                                [
                                    new quest.model.Contents(
                                        1,
                                        {
                                            metadata: "normal",
                                            completeAcquireActions: [
                                                new jobQueue.stampSheet.PushByUserId(
                                                    "namespace-0001",
                                                    [ new jobQueue.model.JobEntry( "script-0001", "", 3) ],
                                                    "#{userId}"
                                                ),
                                            ]
                                        }
                                    ),
                                ],
                                {
                                    metadata: "stage1-1",
                                    premiseQuestNames: []
                                }
                            ),
                        ]
                    }
                )
            ]
        );
    }
}

console.log(new SampleStack().yaml());  // Generate Template

```

**Python**
```python

from gs2_cdk import Stack, core, quest, job_queue

class SampleStack(Stack):

    def __init__(self):
        super().__init__()
        quest.Namespace(
            stack=self,
            name="namespace-0001",
        ).master_data(
            groups=[
                quest.QuestGroupModel(
                    name='main',
                    options=quest.QuestGroupModelOptions(
                        metadata = 'MAIN',
                        quests = [
                            quest.QuestModel(
                                name='1-1',
                                contents=[
                                    quest.Contents(
                                        weight=99,
                                        options=quest.ContentsOptions(
                                            metadata='normal',
                                            complete_acquire_actions=[
                                                experience.AddExperienceByUserId(
                                                    namespace_name='namespace-0001',
                                                    experience_name='player',
                                                    property_id='player',
                                                    experience_value=30,
                                                    truncate_experience_when_rank_up=False,
                                                    user_id='#{userId}'
                                                ),
                                                inventory.AcquireItemSetByUserId(
                                                    namespace_name='namespace-0001',
                                                    inventory_name='inventory-0001',
                                                    item_name='item-0001',
                                                    acquire_count=1,
                                                    expires_at=0,
                                                    create_new_item_set=False,
                                                    item_set_name="",
                                                    user_id='#{userId}'
                                                ),
                                            ],
                                        ),
                                    ),
                                    quest.Contents(
                                        weight=1,
                                        options=quest.ContentsOptions(
                                            metadata='rare',
                                            complete_acquire_actions=[
                                                experience.AddExperienceByUserId(
                                                    namespace_name='namespace-0001',
                                                    experience_name='player',
                                                    property_id='player',
                                                    experience_value=30,
                                                    truncate_experience_when_rank_up=False,
                                                    user_id='#{userId}'
                                                ),
                                                inventory.AcquireItemSetByUserId(
                                                    namespace_name='namespace-0001',
                                                    inventory_name='inventory-0001',
                                                    item_name='item-0001',
                                                    acquire_count=1,
                                                    expires_at=0,
                                                    create_new_item_set=False,
                                                    item_set_name="",
                                                    user_id='#{userId}'
                                                ),
                                            ],
                                        ),
                                    ),
                                ],
                                options=quest.QuestModelOptions(
                                    metadata='stage1-1',
                                    consume_actions=[
                                        stamina.ConsumeStaminaByUserId(
                                            namespace_name='basic',
                                            stamina_name='quest',
                                            user_id='#{userId}',
                                            consume_value=5
                                        ),
                                    ],
                                    failed_acquire_actions=[
                                        stamina.RecoverStaminaByUserId(
                                            namespace_name='basic',
                                            stamina_name='quest',
                                            user_id='#{userId}',
                                            recover_value=5
                                        ),
                                    ],
                                    premise_quest_names=[],
                                ),
                            ),
                            quest.QuestModel(
                                name='1-2',
                                contents=[
                                    quest.Contents(
                                        weight=98,
                                        options=quest.ContentsOptions(
                                            metadata='normal',
                                            complete_acquire_actions=[
                                                experience.AddExperienceByUserId(
                                                    namespace_name='namespace-0001',
                                                    experience_name='player',
                                                    property_id='player',
                                                    experience_value=30,
                                                    truncate_experience_when_rank_up=False,
                                                    user_id='#{userId}'
                                                ),
                                                inventory.AcquireItemSetByUserId(
                                                    namespace_name='namespace-0001',
                                                    inventory_name='inventory-0001',
                                                    item_name='item-0001',
                                                    acquire_count=1,
                                                    expires_at=0,
                                                    create_new_item_set=False,
                                                    item_set_name="",
                                                    user_id='#{userId}'
                                                ),
                                            ],
                                        ),
                                    ),
                                    quest.Contents(
                                        weight=2,
                                        options=quest.ContentsOptions(
                                            metadata='rare',
                                            complete_acquire_actions=[
                                                experience.AddExperienceByUserId(
                                                    namespace_name='namespace-0001',
                                                    experience_name='player',
                                                    property_id='player',
                                                    experience_value=30,
                                                    truncate_experience_when_rank_up=False,
                                                    user_id='#{userId}'
                                                ),
                                                inventory.AcquireItemSetByUserId(
                                                    namespace_name='namespace-0001',
                                                    inventory_name='inventory-0001',
                                                    item_name='item-0001',
                                                    acquire_count=1,
                                                    expires_at=0,
                                                    create_new_item_set=False,
                                                    item_set_name="",
                                                    user_id='#{userId}'
                                                ),
                                            ],
                                        ),
                                    ),
                                ],
                                options=quest.QuestModelOptions(
                                    metadata='stage1-2',
                                    consume_actions=[
                                        stamina.ConsumeStaminaByUserId(
                                            namespace_name='basic',
                                            stamina_name='quest',
                                            consume_value=5,
                                            user_id='#{userId}'
                                        ),
                                    ],
                                    failed_acquire_actions=[
                                        stamina.RecoverStaminaByUserId(
                                            namespace_name='basic',
                                            stamina_name='quest',
                                            user_id='#{userId}',
                                            recover_value=5
                                        ),
                                    ],
                                    premise_quest_names=[
                                        '1-1',
                                    ],
                                ),
                            ),
                        ]
                    ),
                ),
                quest.QuestGroupModel(
                    name='sub',
                    options=quest.QuestGroupModelOptions(
                        metadata = 'SUB',
                        quests = [
                            quest.QuestModel(
                                name='1-1',
                                contents=[
                                    quest.Contents(
                                        weight=1,
                                        options=quest.ContentsOptions(
                                            metadata='normal',
                                            complete_acquire_actions=[
                                                job_queue.PushByUserId(
                                                    namespace_name='queue-0001',
                                                    jobs=[{'scriptId': 'script-0001', 'args': {}, 'maxTryCount': 3}],
                                                    user_id='#{userId}'
                                                ),
                                            ],
                                        ),
                                    ),
                                ],
                                options=quest.QuestModelOptions(
                                    metadata='stage1-1',
                                    premise_quest_names=[],
                                ),
                            ),
                        ]
                    ),
                ),
            ],
        )

print(SampleStack().yaml())  # Generate Template

```


#### QuestGroupModel

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

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

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

#### QuestModel

クエストモデル<br>

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

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

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

#### Contents

コンテンツ<br>

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

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

#### AcquireAction

入手アクション

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

#### ConsumeAction

消費アクション

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

#### VerifyAction

検証アクション

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

---



