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

# GS2-Stamina Deploy/CDK 레퍼런스

GS2-Deploy의 스택을 생성할 때 사용하는 템플릿 포맷과, CDK를 이용한 각종 언어의 템플릿 출력 구현 예제




## 엔티티

Deploy 처리에서 조작 대상이 되는 리소스

### Namespace

네임스페이스<br>

네임스페이스는 하나의 프로젝트 내에서 동일한 서비스를 서로 다른 용도로 여러 개 이용하기 위한 엔티티입니다.<br>
GS2의 각 서비스는 네임스페이스 단위로 관리됩니다. 네임스페이스가 다르면 동일한 서비스라도 완전히 독립된 데이터 공간으로 취급됩니다.<br>

따라서 각 서비스의 이용을 시작하려면 먼저 네임스페이스를 생성해야 합니다.

#### Request

리소스 생성・갱신 요청

|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string |  | ✓|  |  ~ 128자 | 네임스페이스 이름<br>네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string |  | |  |  ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) |  | |  |  | 트랜잭션 설정<br>스태미나 조작 시 트랜잭션의 처리 방법을 제어하는 설정입니다. |
| overflowTriggerScript | string |  | |  |  ~ 1024자 | 오버플로우 트리거 스크립트<br>회복 시 스태미나가 오버플로우될 때 호출되는 GS2-Script의 GRN입니다.<br>시간 기반 회복으로 스태미나가 최대값을 초과하는 경우에 트리거되며, 초과분에 대한 커스텀 처리(예: 오버플로우분을 아이템으로 변환)가 가능합니다.<br>Script 트리거 레퍼런스 - [`overflow`](../script/#overflow) |
| logSetting | [LogSetting](#logsetting) |  | |  |  | 로그 출력 설정<br>스태미나의 소비, 회복, 오버플로우 등의 조작을 GS2-Log에 기록하기 위한 로그 출력 설정입니다. |

#### GetAttr

[!GetAttr](/articles/tech/deploy/#getattr) 태그로 취득 가능한 리소스 생성 결과

| | 타입 | 설명 |
| --- | --- | --- |
| Item | [Namespace](../sdk#namespace) | 생성한 네임스페이스

#### 구현 예제




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

Type: GS2::Stamina::Namespace
Properties:
  Name: namespace-0001
  Description: null
  TransactionSetting: null
  OverflowTriggerScript: grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script
  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/stamina"
    "github.com/openlyinc/pointy"
)


SampleStack := core.NewStack()
stamina.NewNamespace(
    &SampleStack,
    "namespace-0001",
    stamina.NamespaceOptions{
        OverflowTriggerScript: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script"),
        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\Stamina\Model\Namespace_(
            stack: $this,
            name: "namespace-0001",
            options: new \Gs2Cdk\Stamina\Model\Options\NamespaceOptions(
                overflowTriggerScript: "grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script",
                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.stamina.model.Namespace(
                this,
                "namespace-0001",
                new io.gs2.cdk.stamina.model.options.NamespaceOptions()
                        .withOverflowTriggerScript("grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script")
                        .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.Gs2Stamina.Model.Namespace(
            stack: this,
            name: "namespace-0001",
            options: new Gs2Cdk.Gs2Stamina.Model.Options.NamespaceOptions
            {
                overflowTriggerScript = "grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script",
                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 stamina from "@/gs2cdk/stamina";

class SampleStack extends core.Stack
{
    public constructor() {
        super();
        new stamina.model.Namespace(
            this,
            "namespace-0001",
            {
                overflowTriggerScript: "grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script",
                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, stamina

class SampleStack(Stack):

    def __init__(self):
        super().__init__()
        stamina.Namespace(
            stack=self,
            name='namespace-0001',
            options=stamina.NamespaceOptions(
                overflow_trigger_script='grn:gs2:ap-northeast-1:YourOwnerId:script:namespace-0001:script:script',
                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 |

#### 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로 지정해야 합니다. |

---

### CurrentStaminaMaster

현재 활성화된 스태미나 모델의 마스터 데이터<br>

현재 네임스페이스 내에서 유효한 스태미나 모델의 정의를 기술한 마스터 데이터입니다.<br>
GS2에서는 마스터 데이터 관리에 JSON 형식의 파일을 사용합니다.<br>
파일을 업로드함으로써 실제로 서버에 설정을 반영할 수 있습니다.<br>

JSON 파일을 작성하는 방법으로, 매니지먼트 콘솔 내에 마스터 데이터 에디터를 제공하고 있습니다.<br>
또한 게임 운영에 더 적합한 도구를 직접 제작하여 적절한 형식의 JSON 파일을 출력하는 방식으로도 서비스를 이용할 수 있습니다.
**ℹ️ Note**

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

#### Request

리소스 생성・갱신 요청

|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string |  | ✓|  |  ~ 128자 | 네임스페이스 이름<br>네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| mode | 문자열 열거형<br>enum {<br>"direct",<br>"preUpload"<br>}<br> |  | | "direct" |  | 업데이트 모드direct: 마스터 데이터를 직접 업데이트 / preUpload: 마스터 데이터를 업로드한 후 업데이트 /  |
| settings | string | {mode} == "direct" | ✓※|  |  ~ 5242880 바이트 (5MB) | 마스터 데이터<br>※ mode이(가) "direct" 이면 필수 |
| uploadToken | string | {mode} == "preUpload" | ✓※|  |  ~ 1024자 | 사전 업로드로 획득한 토큰<br>업로드한 마스터 데이터를 적용하기 위해 사용됩니다.<br>※ mode이(가) "preUpload" 이면 필수 |

#### GetAttr

[!GetAttr](/articles/tech/deploy/#getattr) 태그로 취득 가능한 리소스 생성 결과

| | 타입 | 설명 |
| --- | --- | --- |
| Item | [CurrentStaminaMaster](../sdk#currentstaminamaster) | 업데이트된 현재 활성화된 스태미나 모델의 마스터 데이터

#### 구현 예제




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

Type: GS2::Stamina::CurrentStaminaMaster
Properties:
  NamespaceName: namespace-0001
  Mode: direct
  Settings: {
    "version": "2019-02-14",
    "staminaModels": [
      {
        "name": "quest",
        "recoverIntervalMinutes": 15,
        "recoverValue": 1,
        "initialCapacity": 50,
        "isOverflow": true,
        "metadata": "QUEST",
        "maxCapacity": 999,
        "maxStaminaTable":
          {
            "name": "playerLevel",
            "metadata": "PLAYER_LEVEL",
            "experienceModelId": "playerLevel",
            "values": [
              51,
              52,
              53,
              54,
              55
            ]
          },
        "recoverIntervalTable":
          {
            "name": "staminaRecoverInterval",
            "metadata": "STAMINA_RECOVER_INTERVAL",
            "experienceModelId": "playerLevel",
            "values": [
              41,
              42,
              43,
              44,
              45
            ]
          },
        "recoverValueTable":
          {
            "name": "staminaRecoverValue",
            "metadata": "STAMINA_RECOVER_VALUE",
            "experienceModelId": "playerLevel",
            "values": [
              31,
              32,
              33,
              34,
              35
            ]
          }
      },
      {
        "name": "raidBattle",
        "recoverIntervalMinutes": 60,
        "recoverValue": 1,
        "initialCapacity": 10,
        "isOverflow": false,
        "metadata": "RAID_BATTLE"
      },
      {
        "name": "special",
        "recoverIntervalMinutes": 30,
        "recoverValue": 3,
        "initialCapacity": 100,
        "isOverflow": true,
        "metadata": "SPECIAL",
        "maxCapacity": 999,
        "maxStaminaTable":
          {
            "name": "special",
            "metadata": "SPECIAL",
            "experienceModelId": "special",
            "values": [
              102,
              104,
              106,
              108,
              110
            ]
          }
      }
    ]
  }
  UploadToken: null

```

**Go**
```go

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


SampleStack := core.NewStack()
stamina.NewNamespace(
    &SampleStack,
    "namespace-0001",
    stamina.NamespaceOptions{},
).MasterData(
    []stamina.StaminaModel{
        stamina.NewStaminaModel(
            "quest",
            15,
            1,
            50,
            true,
            stamina.StaminaModelOptions{
                Metadata: pointy.String("QUEST"),
                MaxCapacity: pointy.Int32(999),
                MaxStaminaTable: &stamina.MaxStaminaTable{
                    Name: "playerLevel",
                    ExperienceModelId: "playerLevel",
                    Values: []int32{
                        51,
                        52,
                        53,
                        54,
                        55,
                    },
                    Metadata: pointy.String("PLAYER_LEVEL"),
                },
                RecoverIntervalTable: &stamina.RecoverIntervalTable{
                    Name: "staminaRecoverInterval",
                    ExperienceModelId: "playerLevel",
                    Values: []int32{
                        41,
                        42,
                        43,
                        44,
                        45,
                    },
                    Metadata: pointy.String("STAMINA_RECOVER_INTERVAL"),
                },
                RecoverValueTable: &stamina.RecoverValueTable{
                    Name: "staminaRecoverValue",
                    ExperienceModelId: "playerLevel",
                    Values: []int32{
                        31,
                        32,
                        33,
                        34,
                        35,
                    },
                    Metadata: pointy.String("STAMINA_RECOVER_VALUE"),
                },
            },
        ),
        stamina.NewStaminaModel(
            "raidBattle",
            60,
            1,
            10,
            false,
            stamina.StaminaModelOptions{
                Metadata: pointy.String("RAID_BATTLE"),
            },
        ),
        stamina.NewStaminaModel(
            "special",
            30,
            3,
            100,
            true,
            stamina.StaminaModelOptions{
                Metadata: pointy.String("SPECIAL"),
                MaxCapacity: pointy.Int32(999),
                MaxStaminaTable: &stamina.MaxStaminaTable{
                    Name: "special",
                    ExperienceModelId: "special",
                    Values: []int32{
                        102,
                        104,
                        106,
                        108,
                        110,
                    },
                    Metadata: pointy.String("SPECIAL"),
                },
            },
        ),
    },
)

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

```

**PHP**
```php

class SampleStack extends \Gs2Cdk\Core\Model\Stack
{
    function __construct() {
        parent::__construct();
        (new \Gs2Cdk\Stamina\Model\Namespace_(
            stack: $this,
            name: "namespace-0001"
        ))->masterData(
            [
                new \Gs2Cdk\Stamina\Model\StaminaModel(
                    name:"quest",
                    recoverIntervalMinutes:15,
                    recoverValue:1,
                    initialCapacity:50,
                    isOverflow:true,
                    options: new \Gs2Cdk\Stamina\Model\Options\StaminaModelOptions(
                        metadata:"QUEST",
                        maxCapacity:999,
                        maxStaminaTable:new \Gs2Cdk\Stamina\Model\MaxStaminaTable(
                            name: "playerLevel",
                            experienceModelId: "playerLevel",
                            values: [
                                51,
                                52,
                                53,
                                54,
                                55,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\MaxStaminaTableOptions(
                                metadata: "PLAYER_LEVEL",
                            ),
                        ),
                        recoverIntervalTable:new \Gs2Cdk\Stamina\Model\RecoverIntervalTable(
                            name: "staminaRecoverInterval",
                            experienceModelId: "playerLevel",
                            values: [
                                41,
                                42,
                                43,
                                44,
                                45,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\RecoverIntervalTableOptions(
                                metadata: "STAMINA_RECOVER_INTERVAL",
                            ),
                        ),
                        recoverValueTable:new \Gs2Cdk\Stamina\Model\RecoverValueTable(
                            name: "staminaRecoverValue",
                            experienceModelId: "playerLevel",
                            values: [
                                31,
                                32,
                                33,
                                34,
                                35,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\RecoverValueTableOptions(
                                metadata: "STAMINA_RECOVER_VALUE",
                            ),
                        )
                    )
                ),
                new \Gs2Cdk\Stamina\Model\StaminaModel(
                    name:"raidBattle",
                    recoverIntervalMinutes:60,
                    recoverValue:1,
                    initialCapacity:10,
                    isOverflow:false,
                    options: new \Gs2Cdk\Stamina\Model\Options\StaminaModelOptions(
                        metadata:"RAID_BATTLE"
                    )
                ),
                new \Gs2Cdk\Stamina\Model\StaminaModel(
                    name:"special",
                    recoverIntervalMinutes:30,
                    recoverValue:3,
                    initialCapacity:100,
                    isOverflow:true,
                    options: new \Gs2Cdk\Stamina\Model\Options\StaminaModelOptions(
                        metadata:"SPECIAL",
                        maxCapacity:999,
                        maxStaminaTable:new \Gs2Cdk\Stamina\Model\MaxStaminaTable(
                            name: "special",
                            experienceModelId: "special",
                            values: [
                                102,
                                104,
                                106,
                                108,
                                110,
                            ],
                            options: new \Gs2Cdk\Stamina\Model\Options\MaxStaminaTableOptions(
                                metadata: "SPECIAL",
                            ),
                        )
                    )
                )
            ]
        );
    }
}

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

```

**Java**
```java

class SampleStack extends io.gs2.cdk.core.model.Stack
{
    public SampleStack() {
        super();
        new io.gs2.cdk.stamina.model.Namespace(
            this,
            "namespace-0001"
        ).masterData(
            Arrays.asList(
                new io.gs2.cdk.stamina.model.StaminaModel(
                    "quest",
                    15,
                    1,
                    50,
                    true,
                    new io.gs2.cdk.stamina.model.options.StaminaModelOptions()
                        .withMetadata("QUEST")
                        .withMaxCapacity(999)
                        .withMaxStaminaTable(new io.gs2.cdk.stamina.model.MaxStaminaTable(
                            "playerLevel",
                            "playerLevel",
                            Arrays.asList(
                                51,
                                52,
                                53,
                                54,
                                55
                            ),
                            new io.gs2.cdk.stamina.model.options.MaxStaminaTableOptions()
                                .withMetadata("PLAYER_LEVEL")
                        ))
                        .withRecoverIntervalTable(new io.gs2.cdk.stamina.model.RecoverIntervalTable(
                            "staminaRecoverInterval",
                            "playerLevel",
                            Arrays.asList(
                                41,
                                42,
                                43,
                                44,
                                45
                            ),
                            new io.gs2.cdk.stamina.model.options.RecoverIntervalTableOptions()
                                .withMetadata("STAMINA_RECOVER_INTERVAL")
                        ))
                        .withRecoverValueTable(new io.gs2.cdk.stamina.model.RecoverValueTable(
                            "staminaRecoverValue",
                            "playerLevel",
                            Arrays.asList(
                                31,
                                32,
                                33,
                                34,
                                35
                            ),
                            new io.gs2.cdk.stamina.model.options.RecoverValueTableOptions()
                                .withMetadata("STAMINA_RECOVER_VALUE")
                        ))
                ),
                new io.gs2.cdk.stamina.model.StaminaModel(
                    "raidBattle",
                    60,
                    1,
                    10,
                    false,
                    new io.gs2.cdk.stamina.model.options.StaminaModelOptions()
                        .withMetadata("RAID_BATTLE")
                ),
                new io.gs2.cdk.stamina.model.StaminaModel(
                    "special",
                    30,
                    3,
                    100,
                    true,
                    new io.gs2.cdk.stamina.model.options.StaminaModelOptions()
                        .withMetadata("SPECIAL")
                        .withMaxCapacity(999)
                        .withMaxStaminaTable(new io.gs2.cdk.stamina.model.MaxStaminaTable(
                            "special",
                            "special",
                            Arrays.asList(
                                102,
                                104,
                                106,
                                108,
                                110
                            ),
                            new io.gs2.cdk.stamina.model.options.MaxStaminaTableOptions()
                                .withMetadata("SPECIAL")
                        ))
                )
            )
        );
    }
}

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

```

**C#**
```csharp

public class SampleStack : Gs2Cdk.Core.Model.Stack
{
    public SampleStack() {
        new Gs2Cdk.Gs2Stamina.Model.Namespace(
            stack: this,
            name: "namespace-0001"
        ).MasterData(
            new Gs2Cdk.Gs2Stamina.Model.StaminaModel[] {
                new Gs2Cdk.Gs2Stamina.Model.StaminaModel(
                    name: "quest",
                    recoverIntervalMinutes: 15,
                    recoverValue: 1,
                    initialCapacity: 50,
                    isOverflow: true,
                    options: new Gs2Cdk.Gs2Stamina.Model.Options.StaminaModelOptions
                    {
                        metadata = "QUEST",
                        maxCapacity = 999,
                        maxStaminaTable = new Gs2Cdk.Gs2Stamina.Model.MaxStaminaTable(
                            name: "playerLevel",
                            experienceModelId: "playerLevel",
                            values: new int[]
                            {
                                51,
                                52,
                                53,
                                54,
                                55,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.MaxStaminaTableOptions
                            {
                                metadata = "PLAYER_LEVEL"
                            }
                        ),
                        recoverIntervalTable = new Gs2Cdk.Gs2Stamina.Model.RecoverIntervalTable(
                            name: "staminaRecoverInterval",
                            experienceModelId: "playerLevel",
                            values: new int[]
                            {
                                41,
                                42,
                                43,
                                44,
                                45,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.RecoverIntervalTableOptions
                            {
                                metadata = "STAMINA_RECOVER_INTERVAL"
                            }
                        ),
                        recoverValueTable = new Gs2Cdk.Gs2Stamina.Model.RecoverValueTable(
                            name: "staminaRecoverValue",
                            experienceModelId: "playerLevel",
                            values: new int[]
                            {
                                31,
                                32,
                                33,
                                34,
                                35,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.RecoverValueTableOptions
                            {
                                metadata = "STAMINA_RECOVER_VALUE"
                            }
                        )
                    }
                ),
                new Gs2Cdk.Gs2Stamina.Model.StaminaModel(
                    name: "raidBattle",
                    recoverIntervalMinutes: 60,
                    recoverValue: 1,
                    initialCapacity: 10,
                    isOverflow: false,
                    options: new Gs2Cdk.Gs2Stamina.Model.Options.StaminaModelOptions
                    {
                        metadata = "RAID_BATTLE"
                    }
                ),
                new Gs2Cdk.Gs2Stamina.Model.StaminaModel(
                    name: "special",
                    recoverIntervalMinutes: 30,
                    recoverValue: 3,
                    initialCapacity: 100,
                    isOverflow: true,
                    options: new Gs2Cdk.Gs2Stamina.Model.Options.StaminaModelOptions
                    {
                        metadata = "SPECIAL",
                        maxCapacity = 999,
                        maxStaminaTable = new Gs2Cdk.Gs2Stamina.Model.MaxStaminaTable(
                            name: "special",
                            experienceModelId: "special",
                            values: new int[]
                            {
                                102,
                                104,
                                106,
                                108,
                                110,
                            },
                            options: new Gs2Cdk.Gs2Stamina.Model.Options.MaxStaminaTableOptions
                            {
                                metadata = "SPECIAL"
                            }
                        )
                    }
                )
            }
        );
    }
}

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

```

**TypeScript**
```typescript

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

class SampleStack extends core.Stack
{
    public constructor() {
        super();
        new stamina.model.Namespace(
            this,
            "namespace-0001",
        ).masterData(
            [
                new stamina.model.StaminaModel(
                    "quest",
                    15,
                    1,
                    50,
                    true,
                    {
                        metadata: "QUEST",
                        maxCapacity: 999,
                        maxStaminaTable: new stamina.model.MaxStaminaTable(
                            "playerLevel",
                            "playerLevel",
                            [
                                51,
                                52,
                                53,
                                54,
                                55,
                            ],
                            {
                                metadata: "PLAYER_LEVEL"
                            }
                        ),
                        recoverIntervalTable: new stamina.model.RecoverIntervalTable(
                            "staminaRecoverInterval",
                            "playerLevel",
                            [
                                41,
                                42,
                                43,
                                44,
                                45,
                            ],
                            {
                                metadata: "STAMINA_RECOVER_INTERVAL"
                            }
                        ),
                        recoverValueTable: new stamina.model.RecoverValueTable(
                            "staminaRecoverValue",
                            "playerLevel",
                            [
                                31,
                                32,
                                33,
                                34,
                                35,
                            ],
                            {
                                metadata: "STAMINA_RECOVER_VALUE"
                            }
                        )
                    }
                ),
                new stamina.model.StaminaModel(
                    "raidBattle",
                    60,
                    1,
                    10,
                    false,
                    {
                        metadata: "RAID_BATTLE"
                    }
                ),
                new stamina.model.StaminaModel(
                    "special",
                    30,
                    3,
                    100,
                    true,
                    {
                        metadata: "SPECIAL",
                        maxCapacity: 999,
                        maxStaminaTable: new stamina.model.MaxStaminaTable(
                            "special",
                            "special",
                            [
                                102,
                                104,
                                106,
                                108,
                                110,
                            ],
                            {
                                metadata: "SPECIAL"
                            }
                        )
                    }
                )
            ]
        );
    }
}

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

```

**Python**
```python

from gs2_cdk import Stack, core, stamina

class SampleStack(Stack):

    def __init__(self):
        super().__init__()
        stamina.Namespace(
            stack=self,
            name="namespace-0001",
        ).master_data(
            stamina_models=[
                stamina.StaminaModel(
                    name='quest',
                    recover_interval_minutes=15,
                    recover_value=1,
                    initial_capacity=50,
                    is_overflow=True,
                    options=stamina.StaminaModelOptions(
                        metadata = 'QUEST',
                        max_capacity = 999,
                        max_stamina_table = stamina.MaxStaminaTable(
                            name='playerLevel',
                            experience_model_id='playerLevel',
                            values=[
                                51,
                                52,
                                53,
                                54,
                                55,
                            ],
                            options=stamina.MaxStaminaTableOptions(
                                metadata='PLAYER_LEVEL',
                            ),
                        ),
                        recover_interval_table = stamina.RecoverIntervalTable(
                            name='staminaRecoverInterval',
                            experience_model_id='playerLevel',
                            values=[
                                41,
                                42,
                                43,
                                44,
                                45,
                            ],
                            options=stamina.RecoverIntervalTableOptions(
                                metadata='STAMINA_RECOVER_INTERVAL',
                            ),
                        ),
                        recover_value_table = stamina.RecoverValueTable(
                            name='staminaRecoverValue',
                            experience_model_id='playerLevel',
                            values=[
                                31,
                                32,
                                33,
                                34,
                                35,
                            ],
                            options=stamina.RecoverValueTableOptions(
                                metadata='STAMINA_RECOVER_VALUE',
                            ),
                        )
                    ),
                ),
                stamina.StaminaModel(
                    name='raidBattle',
                    recover_interval_minutes=60,
                    recover_value=1,
                    initial_capacity=10,
                    is_overflow=False,
                    options=stamina.StaminaModelOptions(
                        metadata = 'RAID_BATTLE'
                    ),
                ),
                stamina.StaminaModel(
                    name='special',
                    recover_interval_minutes=30,
                    recover_value=3,
                    initial_capacity=100,
                    is_overflow=True,
                    options=stamina.StaminaModelOptions(
                        metadata = 'SPECIAL',
                        max_capacity = 999,
                        max_stamina_table = stamina.MaxStaminaTable(
                            name='special',
                            experience_model_id='special',
                            values=[
                                102,
                                104,
                                106,
                                108,
                                110,
                            ],
                            options=stamina.MaxStaminaTableOptions(
                                metadata='SPECIAL',
                            ),
                        )
                    ),
                ),
            ],
        )

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

```


#### StaminaModel

스태미나 모델<br>

스태미나의 최대값, 회복 간격, 회복량과 같은 파라미터를 정의할 수 있습니다.<br>
GS2-Experience와 연동하여 최대값이나 회복량을 제어할 수도 있습니다.

|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| staminaModelId | string |  | ※ |  |  ~ 1024자 | 스타미나 모델 GRN<br>※ 서버가 자동으로 설정 |
| name | string |  | ✓ |  |  ~ 128자 | 스태미나 모델 이름<br>스태미나 모델 고유의 이름. 영숫자 및 -(하이픈) _(밑줄) .(마침표)로 지정합니다. |
| metadata | string |  |  |  |  ~ 128자 | 메타데이터<br>메타데이터에는 임의의 값을 설정할 수 있습니다.<br>이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| recoverIntervalMinutes | int |  | ✓ |  | 0 ~ 2147483646 | 회복 간격(분)<br>스태미나 회복 틱의 간격(분 단위)입니다.<br>이 간격이 경과할 때마다 플레이어의 스태미나가 회복량만큼 증가합니다.<br>RecoverIntervalTable을 사용하여 GS2-Experience의 랭크별로 사용자 단위로 오버라이드할 수 있습니다.<br>0으로 설정하면 시간 기반 자동 회복이 비활성화됩니다. |
| recoverValue | int |  |  | 1 | 0 ~ 2147483646 | 회복량<br>회복 틱마다 회복되는 스태미나의 양입니다.<br>회복 간격이 경과할 때마다 최대값에 도달할 때까지 이 값만큼 스태미나가 증가합니다.<br>RecoverValueTable을 사용하여 GS2-Experience의 랭크별로 사용자 단위로 오버라이드할 수 있습니다.<br>기본값은 1입니다. |
| initialCapacity | int |  | ✓ |  | 0 ~ 2147483646 | 최대값의 초기값<br>모든 플레이어에 대한 기본 스태미나 최대값입니다.<br>오버플로우가 비활성화된 경우, 사용자별 최대값의 하한으로 작용합니다.<br>MaxStaminaTable을 사용하여 GS2-Experience의 랭크별로 사용자 단위로 오버라이드할 수 있습니다. |
| isOverflow | bool |  | ✓ |  |  | 오버플로우 가능 여부<br>아이템 사용 등의 수단으로 스태미나가 초기 최대값을 초과할 수 있는지 여부입니다.<br>활성화된 경우, 스태미나는 initialCapacity를 초과하여 maxCapacity까지 설정할 수 있습니다. 자연 회복은 일반적인 최대값에서 정지합니다.<br>비활성화된 경우, 사용자별 최대값은 initialCapacity 이상으로 제한됩니다. |
| maxCapacity | int | {isOverflow} == true | ✓※ |  | 0 ~ 2147483646 | 오버플로우 시 최대값<br>오버플로우 활성화 시 스태미나의 절대 상한값입니다.<br>오버플로우 상태에서도 스태미나는 이 값을 초과할 수 없습니다. isOverflow가 true인 경우에만 표시됩니다.<br>예를 들어 initialCapacity가 100, maxCapacity가 200인 경우, 아이템으로 스태미나를 200까지 늘릴 수 있지만 자연 회복은 100에서 정지합니다.<br>※ isOverflow이(가) true 이면 필수 |
| maxStaminaTable | [MaxStaminaTable](#maxstaminatable) |  |  |  |  | 스태미나 최대값 테이블<br>플레이어의 GS2-Experience 랭크에 기반하여 스태미나 최대값을 동적으로 결정하는 MaxStaminaTable에 대한 참조입니다.<br>설정 시, 플레이어의 최대 스태미나는 현재 랭크 인덱스로 테이블에서 참조되며, initialCapacity를 오버라이드합니다.<br>미설정 시, 모든 플레이어가 동일한 initialCapacity를 최대값으로 공유합니다. |
| recoverIntervalTable | [RecoverIntervalTable](#recoverintervaltable) |  |  |  |  | 회복 간격 테이블<br>플레이어의 GS2-Experience 랭크에 기반하여 회복 간격을 동적으로 결정하는 RecoverIntervalTable에 대한 참조입니다.<br>설정 시, 플레이어의 회복 간격은 현재 랭크 인덱스로 테이블에서 참조되며, recoverIntervalMinutes를 오버라이드합니다.<br>미설정 시, 모든 플레이어가 동일한 recoverIntervalMinutes를 공유합니다. |
| recoverValueTable | [RecoverValueTable](#recovervaluetable) |  |  |  |  | 회복량 테이블<br>플레이어의 GS2-Experience 랭크에 기반하여 회복량을 동적으로 결정하는 RecoverValueTable에 대한 참조입니다.<br>설정 시, 플레이어의 회복량은 현재 랭크 인덱스로 테이블에서 참조되며, recoverValue를 오버라이드합니다.<br>미설정 시, 모든 플레이어가 동일한 recoverValue를 공유합니다. |

#### MaxStaminaTable

스태미나 최대값 테이블<br>

스태미나 최대값 테이블은 GS2-Experience의 랭크별로 스태미나의 최대값을 정의하는 엔티티입니다.

|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string |  | ✓ |  |  ~ 128자 | 스태미나 최대값 테이블 이름<br>스태미나 최대값 테이블 고유의 이름. 영숫자 및 -(하이픈) _(밑줄) .(마침표)로 지정합니다. |
| metadata | string |  |  |  |  ~ 128자 | 메타데이터<br>메타데이터에는 임의의 값을 설정할 수 있습니다.<br>이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| experienceModelId | string |  | ✓ |  |  ~ 1024자 | 경험치 모델 ID<br>플레이어의 현재 랭크를 참조하기 위해 사용하는 GS2-Experience의 ExperienceModel의 GRN.<br>랭크 인덱스가 values 목록의 배열 인덱스로 사용되어, 사용자별 스태미나 최대값이 결정됩니다. |
| values | List&lt;int&gt; |  | ✓ |  | 1 ~ 1024 items | 랭크별 스태미나 최대값<br>플레이어의 GS2-Experience 랭크 인덱스로 색인되는 스태미나 최대값의 배열.<br>인덱스 i의 값이 랭크 i의 플레이어의 최대 스태미나로 사용됩니다. 배열 길이는 참조하는 ExperienceModel에서 정의된 랭크 수와 일치해야 합니다. |

#### RecoverIntervalTable

회복 간격 테이블<br>

회복 간격 테이블은 GS2-Experience의 랭크별로 스태미나의 회복 간격을 정의하는 엔티티입니다.

|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string |  | ✓ |  |  ~ 128자 | 회복 간격 테이블 이름<br>회복 간격 테이블 고유의 이름. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| metadata | string |  |  |  |  ~ 128자 | 메타데이터<br>메타데이터에는 임의의 값을 설정할 수 있습니다.<br>이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| experienceModelId | string |  | ✓ |  |  ~ 1024자 | 경험치 모델 ID<br>플레이어의 현재 랭크를 참조하기 위해 사용하는 GS2-Experience의 ExperienceModel의 GRN.<br>랭크 인덱스가 values 목록의 배열 인덱스로 사용되어, 사용자별 회복 간격이 결정됩니다. |
| values | List&lt;int&gt; |  | ✓ |  | 1 ~ 1024 items | 랭크별 회복 간격<br>플레이어의 GS2-Experience 랭크 인덱스로 색인되는 회복 간격 값(분 단위)의 배열.<br>인덱스 i의 값이 랭크 i의 플레이어의 회복 간격으로 사용되며, 모델의 기본값 recoverIntervalMinutes를 오버라이드합니다. |

#### RecoverValueTable

스태미나 회복량 테이블<br>

스태미나 회복량 테이블은 GS2-Experience의 랭크별로 스태미나의 회복량을 정의하는 엔티티입니다.

|  | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string |  | ✓ |  |  ~ 128자 | 스태미나 회복량 테이블 이름<br>스태미나 회복량 테이블 고유의 이름. 영숫자 및 -(하이픈) _(밑줄) .(마침표)로 지정합니다. |
| metadata | string |  |  |  |  ~ 128자 | 메타데이터<br>메타데이터에는 임의의 값을 설정할 수 있습니다.<br>이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| experienceModelId | string |  | ✓ |  |  ~ 1024자 | 경험치 모델 ID<br>플레이어의 현재 랭크를 참조하기 위해 사용하는 GS2-Experience의 ExperienceModel의 GRN.<br>랭크 인덱스가 values 목록의 배열 인덱스로 사용되어, 사용자별 회복량이 결정됩니다. |
| values | List&lt;int&gt; |  | ✓ |  | 1 ~ 1024 items | 랭크별 회복량<br>플레이어의 GS2-Experience 랭크 인덱스로 색인되는 회복량 값의 배열입니다.<br>인덱스 i의 값은 랭크 i의 플레이어에 대한 틱당 회복량으로 사용되며, 모델의 기본 recoverValue를 오버라이드합니다. |

---