{
    "publicApi": {
        "application": {
            "action": {
                "admin": {
                    "setApprovalState": {
                        "approved": {
                            "buttonText": "승인",
                            "heading": "애플리케이션 승인",
                            "text": "이 애플리케이션을 승인하시겠습니까?"
                        },
                        "deny": {
                            "buttonText": "거부",
                            "heading": "애플리케이션 거부",
                            "text": "이 애플리케이션의 API 접근을 막기 위해 거부하시겠습니까?"
                        },
                        "description": "애플리케이션의 승인 상태를 설정합니다.",
                        "heading": "승인 상태 설정",
                        "pendingApproval": {
                            "buttonText": "승인 요청",
                            "heading": "애플리케이션 승인 요청",
                            "text": "이 애플리케이션에 대한 승인을 요청하시겠습니까?"
                        },
                        "setup": {
                            "buttonText": "초기화",
                            "heading": "애플리케이션 초기화",
                            "text": "애플리케이션을 설정 상태로 변경하고 개발용 API 접근을 허용합니다."
                        },
                        "success": {
                            "heading": "승인 상태가 업데이트됨",
                            "text": "애플리케이션의 승인 상태가 업데이트되었습니다."
                        }
                    },
                    "upgradeToGameIntegration": {
                        "buttonText": "게임 연동으로 업그레이드",
                        "heading": "게임 연동으로 업그레이드",
                        "text": "이 애플리케이션을 게임 연동으로 변경합니다. 병합할 새 보안 컨텍스트를 생성하며, 아직 연동이 없다면 새 연동도 생성합니다."
                    }
                },
                "copyAppId": "앱 ID 복사",
                "delete": {
                    "buttonText": "삭제",
                    "heading": "애플리케이션 삭제",
                    "text": "이 애플리케이션을 삭제하시겠습니까?"
                },
                "goToApp": "앱으로 이동"
            },
            "applicationState": {
                "activated": {
                    "name": "활성",
                    "description": "이 앱은 활성 상태입니다."
                },
                "deactivated": {
                    "name": "비활성",
                    "description": "이 앱은 비활성화되었습니다."
                },
                "label": "애플리케이션 상태",
                "removed": {
                    "name": "제거됨",
                    "description": "이 앱은 제거되었습니다."
                },
                "any": "모든 상태"
            },
            "applicationType": {
                "discordBot": {
                    "name": "디스코드 봇"
                },
                "gameIntegration": {
                    "name": "게임 연동"
                },
                "label": "애플리케이션 유형",
                "other": {
                    "name": "기타"
                },
                "website": {
                    "name": "웹사이트"
                },
                "unknown": {
                    "name": "알 수 없음"
                },
                "any": "모든 유형"
            },
            "approvalState": {
                "approved": {
                    "name": "승인됨",
                    "details": {
                        "fullProductionRateLimits": "전체 프로덕션 속도 제한이 적용됩니다."
                    },
                    "description": "이 앱은 {{tenant}}의 승인을 받았습니다."
                },
                "denied": {
                    "name": "거부됨",
                    "details": {
                        "contactSupport": "오류라고 생각되면 지원팀에 문의하세요.",
                        "deniedByPlatformAdmins": "플랫폼 관리자에 의해 거부되었습니다."
                    },
                    "description": "이 앱은 {{tenant}}에 의해 거부되었습니다."
                },
                "label": "승인 상태",
                "pendingApproval": {
                    "name": "검토 중",
                    "details": {
                        "debugRateLimitsStillApply": "디버그 속도 제한은 계속 적용됩니다.",
                        "underReviewByPlatformAdmins": "플랫폼 관리자 검토 중입니다."
                    },
                    "description": "이 앱은 {{tenant}}의 검토 중입니다."
                },
                "setup": {
                    "name": "설정",
                    "details": {
                        "approvalRequired": "게임을 공개 출시하기 전에 승인이 필요합니다.",
                        "awaitingSubmission": "아직 앱을 승인 심사에 제출하지 않았습니다."
                    },
                    "description": "이 앱은 설정 단계이며 개발용 속도 제한으로 제한됩니다."
                },
                "any": "모든 승인 상태"
            },
            "placeholder": {
                "empty": {
                    "heading": "애플리케이션이 없습니다",
                    "text": "애플리케이션이 없습니다."
                },
                "noApplicationsMatchFilters": {
                    "heading": "필터와 일치하는 애플리케이션이 없습니다",
                    "text": "필터 또는 검색어를 조정해 보세요."
                }
            },
            "base": {
                "application_one": "애플리케이션",
                "application_other": "애플리케이션"
            },
            "backoffice": {
                "heading": "관리자 백오피스",
                "viewInPlatformSettings": "플랫폼 설정에서 보기"
            },
            "menu": {
                "backToDashboard": "대시보드로 돌아가기",
                "items": {
                    "accountLinking": "계정 연결",
                    "appearance": "외형",
                    "credentials": "자격 증명",
                    "gameAssets": "게임 에셋",
                    "gameHandling": "게임 처리",
                    "gameSettings": "게임 설정",
                    "general": "일반",
                    "insights": "인사이트",
                    "overview": "개요",
                    "platformSettings": "플랫폼 설정",
                    "playerReporting": "플레이어 신고",
                    "roles": "역할",
                    "scoringAndResults": "점수 및 결과",
                    "bot": "봇",
                    "spaces": "스페이스",
                    "viewOnPlatform": "플랫폼에서 보기",
                    "viewOnPlatformDeactivated": "애플리케이션이 비활성화되었습니다"
                },
                "sections": {
                    "admin": "관리자",
                    "gameIntegration": "게임 연동",
                    "gameTitle": "게임 타이틀",
                    "general": "일반",
                    "sandbox": "샌드박스"
                }
            },
            "createForm": {
                "applicationTypeLabel": "애플리케이션 유형",
                "applicationTypePlaceholder": "애플리케이션 유형을 선택하세요...",
                "nameLabel": "이름",
                "namePlaceholder": "애플리케이션 이름 입력",
                "termsText": "애플리케이션을 생성하면 <1>{{platformName}} API 이용 약관</1>에 동의하게 됩니다."
            },
            "root": {
                "aboutHeading": "소개",
                "appInfo": {
                    "heading": "앱 정보",
                    "save": "저장"
                },
                "actions": {
                    "description": "애플리케이션의 운영 상태를 관리합니다.",
                    "heading": "작업"
                },
                "applicationId": "애플리케이션 ID",
                "checklist": {
                    "complete": "{{done}} / {{total}} 단계 완료",
                    "completeAllStepsToSubmit": "제출하려면 모든 체크리스트 단계를 완료하세요.",
                    "hide": "체크리스트 숨기기",
                    "view": "체크리스트 보기"
                },
                "confirm": {
                    "delete": {
                        "buttonText": "삭제",
                        "heading": "애플리케이션 삭제",
                        "text": "이 애플리케이션을 삭제하시겠습니까?"
                    },
                    "submitForReview": {
                        "buttonText": "제출",
                        "heading": "검토 요청 제출",
                        "text": "애플리케이션을 검토한 뒤 가능한 한 빨리 답변드리겠습니다."
                    },
                    "withdraw": {
                        "buttonText": "철회",
                        "heading": "애플리케이션 철회",
                        "text": "검토 중인 애플리케이션을 철회하시겠습니까?"
                    }
                },
                "gameIntegrationId": "게임 연동 ID",
                "icon": "아이콘",
                "labels": {
                    "intendedUsage": "의도된 사용 방식",
                    "name": "애플리케이션 이름",
                    "owner": "소유자",
                    "rateLimits": "속도 제한"
                },
                "overviewHeading": "개요",
                "platformApproval": {
                    "heading": "플랫폼 승인",
                    "text": "플랫폼 관리자에 의해 관리됩니다. 일반 가용성, 속도 제한 및 기타 플랫폼 수준 제한을 제어합니다."
                },
                "technicalReview": {
                    "heading": "기술 검토 중인 게임",
                    "description": "게임이 현재 기술 검토를 받고 있습니다. 토너먼트 및 기타 경쟁 기능은 일시적으로 사용할 수 없지만, 샌드박스를 사용해 연동을 빌드하고 테스트할 수는 있습니다.",
                    "approvedUnusual": "승인됨 - 게임 브랜드가 할당되지 않음(지원팀 문의)"
                },
                "releaseState": {
                    "description": "게임의 사용 가능 상태를 제어합니다.",
                    "heading": "출시 상태",
                    "lockedLabel": "잠김"
                },
                "statusHeading": "상태",
                "toggle": {
                    "heading": "애플리케이션 {{action}}",
                    "text": "이 애플리케이션을 {{action}}하시겠습니까?"
                },
                "usefulLinks": {
                    "apiTerms": {
                        "heading": "API 이용 약관",
                        "linkText": "약관 읽기",
                        "text": "이 약관은 {{tenant}}의 API를 사용하는 모든 사람에게 적용됩니다."
                    },
                    "documentation": {
                        "heading": "문서",
                        "linkText": "문서 살펴보기",
                        "text": "개발자 제품을 시작하는 데 필요한 모든 정보를 확인하세요."
                    },
                    "heading": "유용한 링크",
                    "support": {
                        "heading": "지원",
                        "linkText": "지원 받기",
                        "text": "채팅으로 문의하거나 개발자 FAQ에서 답을 찾아보세요."
                    }
                }
            },
            "getStarted": {
                "gameIntegration": {
                    "skip": {
                        "heading": "설정을 건너뛰시겠습니까?",
                        "text": "설정 과정을 건너뛰면 게임 연동을 수동으로 설정해야 합니다."
                    },
                    "intro": {
                        "heading": "게임에 대해 알려주세요",
                        "summary": {
                            "basicInfo": {
                                "heading": "기본 정보",
                                "text": "게임 이름과 로고 같은 일반 정보를 알려주세요."
                            },
                            "lobbyAndTeam": {
                                "heading": "로비 및 팀 설정",
                                "text": "게임의 각 로비에서 몇 명의 플레이어와 팀이 경쟁할 수 있나요?"
                            },
                            "scoringAndSettings": {
                                "heading": "점수 및 게임 설정",
                                "text": "게임 승자를 결정하기 위해 점수를 어떻게 계산할지 선택하세요."
                            }
                        }
                    },
                    "steps": {
                        "gameDescriptors": {
                            "heading": "소개",
                            "text": "게임에 대해 알려주세요.",
                            "iconLabel": "아이콘"
                        },
                        "description": {
                            "heading": "소개",
                            "text": "연동 방식과 API의 의도된 사용 방식을 설명해주세요."
                        },
                        "gameType": {
                            "heading": "형식",
                            "text": "배틀로얄 또는 자유 전투 형식처럼 한 로비에서 2개를 초과하는 팀이 동시에 플레이할 수 있나요?",
                            "headToHead": {
                                "heading": "헤드 투 헤드",
                                "text": "게임은 한 로비에서 한 팀이 다른 한 팀과만 플레이할 수 있습니다."
                            },
                            "multiTeam": {
                                "heading": "멀티 팀",
                                "text": "게임에는 한 로비에서 2개보다 많은 팀이 플레이할 수 있는 모드가 하나 이상 있습니다."
                            }
                        },
                        "teamSettings": {
                            "heading": "로비 및 팀 설정",
                            "text": "각 팀과 로비에는 몇 명의 플레이어가 있나요?"
                        },
                        "scoring": {
                            "heading": "점수",
                            "text": "게임 결과가 반영되는 방식에 가장 잘 맞는 점수 템플릿을 선택하거나, 나중에 직접 맞춤 점수를 만들 수 있습니다."
                        },
                        "appearance": {
                            "heading": "외형",
                            "text": "{{tenant}}의 게임 개요 페이지 외형을 구성하세요."
                        }
                    },
                    "success": {
                        "heading": "모든 준비가 끝났습니다!",
                        "text": "함께하게 되어 반갑습니다. 준비가 되면 게임을 검토 요청으로 제출해 {{tenant}}에서 출시 승인받으세요."
                    }
                }
            },
            "card": {
                "contextMenuLabel": "애플리케이션 컨텍스트 메뉴"
            },
            "createModal": {
                "description": "{{platformName}}와 상호작용하기 위해 API를 사용하는 새 애플리케이션을 생성하세요.",
                "heading": "애플리케이션 생성"
            },
            "documentation": {
                "authApi": {
                    "botAccessTokens": {
                        "components": {
                            "botUserInfo": {
                                "description": {
                                    "afterGraphqlLink": "{{platformName}} 클라이언트 API에서 호출해 인증을 테스트할 수 있습니다. 반환되는 subject/user ID는 봇 사용자의 공개 ID에 해당합니다.",
                                    "beforeUserInfoLink": "애플리케이션이 {{platformName}}에서 봇으로 표현되므로",
                                    "betweenLinks": "또는"
                                },
                                "heading": "봇 사용자 정보",
                                "me": "GraphQL 쿼리 Me를"
                            },
                            "callApis": {
                                "description": "액세스 토큰을 Bearer 인증과 함께 사용해 권한이 부여된 엔드포인트를 호출하세요:",
                                "heading": "API 호출"
                            },
                            "exampleBotAccessToken": "봇 액세스 토큰 예시:",
                            "exampleRefreshKey": "리프레시 키 예시:",
                            "heading": "구성 요소",
                            "retrieveBotAccessKey": {
                                "description": {
                                    "afterEndpoint": "API를 사용하세요.",
                                    "beforeEndpoint": "리프레시 키를",
                                    "betweenBadgeAndEndpoint": "으로 교환하려면"
                                },
                                "heading": "봇 액세스 키 가져오기",
                                "steps": {
                                    "generateRefreshKey": {
                                        "description": {
                                            "afterDashboard": "에서 자격 증명 탭으로 이동해 장기 리프레시 키를 생성하세요. 이 키는 한 번만 표시되므로 안전하게 보관하세요.",
                                            "beforeDashboard": "애플리케이션 대시보드"
                                        },
                                        "heading": "리프레시 키 생성",
                                        "items": {
                                            "edit": {
                                                "description": "쉽게 식별할 수 있도록 리프레시 키에 이름을 지정하세요."
                                            },
                                            "generate": {
                                                "description": "리프레시 키를 별도로 생성하고 환경에 안전하게 저장하세요.",
                                                "heading": "생성"
                                            },
                                            "revoke": {
                                                "description": "키가 유출되었거나 교체가 필요하면 폐기하세요. 이렇게 하면 무단 API 액세스를 방지할 수 있습니다.",
                                                "heading": "폐기"
                                            }
                                        }
                                    },
                                    "retrieveBotAccessToken": {
                                        "description": {
                                            "afterBadge": "를 발급받을 수 있습니다. 이 토큰은 특정 API 리소스에 대한 액세스를 부여합니다.",
                                            "afterEndpoint": "엔드포인트를 사용해 수명이 짧은",
                                            "beforeEndpoint": "리프레시 키와"
                                        },
                                        "heading": "봇 액세스 토큰 가져오기"
                                    }
                                }
                            }
                        },
                        "concepts": {
                            "authentication": {
                                "description": {
                                    "afterBotAccess": "방식을 통해 애플리케이션의 ID를 검증합니다.",
                                    "beforeBotAccess": "인증된 요청은"
                                },
                                "heading": "인증"
                            },
                            "authorization": {
                                "description": {
                                    "afterSpace": "이렇게 하면 봇이 해당 스페이스 내에서 리소스를 관리하고, 업데이트를 게시하거나, 허용된 다른 작업을 수행할 수 있습니다.",
                                    "beforeSpace": "플랫폼에서 특정 리소스에 대한 봇 액세스 권한을 부여할 수 있습니다. 예를 들어 봇을 연결할 대상"
                                },
                                "heading": "권한 부여"
                            },
                            "botAccessToSpace": {
                                "description": {
                                    "afterCoAdmin": "스페이스를 대신해 작업을 수행할 수 있게 됩니다. 봇은 해당 스페이스 내에서 리소스를 관리하고, 업데이트를 게시하거나, 허용된 다른 작업을 수행할 수 있습니다.",
                                    "beforeCoAdmin": "{{platformName}} 애플리케이션 대시보드에서 본인이 관리자 권한을 가진 스페이스에 봇을 연결할 수 있습니다. 그러면",
                                    "coAdmin": "봇이 스페이스에 공동 관리자로 추가되어"
                                },
                                "heading": "스페이스에 대한 봇 액세스"
                            },
                            "botAuthentication": {
                                "description": {
                                    "afterBadge": "토큰을 사용합니다. API에서 이 방식을 요구하는 경우 요청은 애플리케이션을 나타내는 봇을 통해 인증되어 안전한 봇 액세스를 보장합니다.",
                                    "beforeBadge": "서버 인증은"
                                },
                                "details": {
                                    "afterDashboard": "액세스 토큰은 수명이 짧으며 기본 유효 시간은 20분입니다. 인증 세부 정보는",
                                    "afterLink": "문서에서 확인하세요.",
                                    "beforeBadge": "새",
                                    "betweenBadgeAndRefreshKey": "토큰을 발급받으려면 다음 장기",
                                    "betweenRefreshKeyAndDashboard": "생성이 필요합니다. 생성 위치:"
                                },
                                "heading": "봇 인증",
                                "refreshKey": "리프레시 키"
                            },
                            "bots": {
                                "description": {
                                    "afterSpaces": "에 부여되면, 봇은 해당 스페이스 안에 표시되며 스페이스별 리소스와 상호작용할 수 있습니다.",
                                    "beforeBot": "여기서",
                                    "betweenBotAccessAndSpaces": "권한이",
                                    "betweenBotAndPlatformName": "역할은 {{platformName}}에서 애플리케이션을 대신해 작업을 수행하고 애플리케이션을 나타내는 것입니다. 기본적으로 봇은 공개 데이터에 액세스할 수 있습니다."
                                },
                                "heading": "봇"
                            },
                            "functionsLabel": "봇의 주요 기능:",
                            "heading": "개념"
                        },
                        "overview": {
                            "description": {
                                "afterBot": "계정을 사용해 애플리케이션을 나타냅니다. 높은 권한이 필요한 작업, 시스템 수준 작업 또는 캐시 가능한 공개 데이터에 액세스할 때 적합합니다. 예시는 다음과 같습니다:",
                                "afterBotAccess": "즉 이 방식은",
                                "afterServerAuthentication": "방식은 애플리케이션을 대신해 작업을 수행할 수 있게 해줍니다."
                            },
                            "examples": {
                                "fetchingPublicTournamentData": {
                                    "description": {
                                        "afterBotAccess": "권한으로 {{platformName}} 클라이언트 API에서 비개인 토너먼트 데이터를 조회할 수 있습니다.",
                                        "beforeBotAccess": "예를 들어"
                                    },
                                    "heading": "공개 토너먼트 데이터 조회"
                                },
                                "postingGameResults": {
                                    "description": "봇을 사용해 게임 세션 결과를 제출하여 {{platformName}}와 게임을 연동하세요.",
                                    "heading": "게임 결과 제출"
                                },
                                "seedingTournaments": {
                                    "description": {
                                        "afterSpace": "단위로 연결해 토너먼트를 프로그래밍 방식으로 관리하고 시드 배정하세요.",
                                        "beforeSpace": "봇을"
                                    },
                                    "heading": "토너먼트 시드 배정"
                                }
                            },
                            "heading": "서버 인증"
                        },
                        "terms": {
                            "bot": "봇",
                            "botAccess": "봇 액세스",
                            "serverAuthentication": "서버 인증",
                            "space": "스페이스",
                            "spaceTitle": "스페이스",
                            "spaces": "스페이스"
                        }
                    },
                    "clientAuthentication": {
                        "overview": {
                            "examples": {
                                "joiningTournament": {
                                    "description": "GraphQL mutation을 사용하면 토너먼트 참가처럼 사용자를 대신한 작업을 수행할 수 있습니다.",
                                    "heading": "토너먼트 참가"
                                },
                                "retrievingPersonalTournamentData": {
                                    "description": "개인 액세스 토큰을 사용해 {{platformName}} 클라이언트 API에서 토너먼트 그래프를 조회하면 사용자의 참가 정보와 같은 토너먼트 관련 개인 정보를 가져올 수 있습니다.",
                                    "heading": "개인 토너먼트 데이터 조회"
                                },
                                "retrievingUserProfile": {
                                    "afterCode": "엔드포인트를 사용해 인증된 사용자의 개인 {{platformName}} 프로필과 현재 진행 중인 활동을 가져옵니다.",
                                    "beforeCode": "다음",
                                    "heading": "사용자 프로필 조회"
                                }
                            },
                            "intro": "사용자 인증은 개인화된 데이터를 조회하거나 사용자 작업을 수행하는 등 사용자를 대신해 {{platformName}} API를 호출할 때 사용됩니다. 예를 들면 다음과 같습니다."
                        },
                        "patAccessTokenOverview": {
                            "afterBadges": "배지로 표시되며, 사용자 인증에 사용되는 토큰입니다. 이 토큰은 수명이 짧은 액세스 토큰이며, 표준 OAuth 2.0 플로우를 사용해 {{platformName}} OAuth 2.0 서버에서 발급됩니다. 이 인증 방식은",
                            "beforeExpandedBadge": "사용자 개인 액세스 토큰은 문서에서",
                            "betweenBadges": "또는",
                            "clientApiLink": "{{platformName}} 클라이언트 API",
                            "outro": "에서 광범위하게 사용됩니다."
                        }
                    },
                    "flows": {
                        "assertion": {
                            "badgeDescription": "Assertion 플로우는 지원되는 ID 공급자가 제공한 assertion 토큰을 OAuth 인가 grant로 사용해 동작하는 비대화형 OAuth 플로우입니다.",
                            "badgeText": "Assertion 플로우",
                            "summary": {
                                "afterBadge": "토큰을 교환하는 방식으로 동작합니다.",
                                "afterLink": "엔드포인트와만 상호작용합니다. 지원되는 ID 공급자가 제공한",
                                "beforeLink": "OAuth 플로우로, 리프레시 토큰 플로우와 마찬가지로",
                                "intro": "Assertion 플로우는",
                                "nonInteractive": "비대화형"
                            }
                        },
                        "authorizationCode": {
                            "badgeText": "인가 코드 플로우",
                            "description": "인가 코드 플로우는 가장 일반적으로 사용되는 플로우입니다. 사용자를 인증 서버로 리디렉션해 동의를 받은 뒤 클라이언트에 인가 코드를 제공합니다. 이 코드는 이후 액세스 토큰으로 교환할 수 있습니다."
                        },
                        "deviceCode": {
                            "badgeText": "디바이스 코드 플로우",
                            "description": "이 플로우는 콘솔처럼 입력이 불편한 디바이스에 최적화되어 있습니다. 사용자에게 디바이스 코드와 URL이 제시되며, 다른 디바이스(예: 휴대전화)에서 이 URL을 방문해 코드를 입력하면 기본 디바이스를 승인하게 됩니다."
                        },
                        "implicitCode": {
                            "badgeText": "Implicit Code 플로우",
                            "description": "이 플로우는 싱글 페이지 애플리케이션처럼 클라이언트 시크릿의 기밀성을 보장할 수 없는 클라이언트를 위해 특별히 설계되었습니다. 교환이 필요한 중간 인증 코드를 받는 대신, 사용자가 동의하면 클라이언트가 액세스 토큰을 직접 획득합니다."
                        },
                        "refreshToken": {
                            "badgeText": "리프레시 토큰 플로우",
                            "description": "리프레시 토큰 플로우는 사용자가 다시 인증하지 않아도 클라이언트가 새 액세스 토큰을 받을 수 있도록 설계되었습니다. 초기 토큰이 만료된 뒤 전체 인증 과정을 반복하는 대신, 리프레시 토큰을 사용해 새 액세스 토큰을 받을 수 있습니다.",
                            "summary": {
                                "afterPatBadge": "토큰을 다시 인증 없이 새로 발급받을 수 있게 해줍니다. 초기 토큰이 만료된 뒤 전체 인증 과정을 반복하는 대신",
                                "afterRefreshBadge": "토큰을 사용해 새",
                                "beforePatBadge": "리프레시 토큰 플로우는 사용자가 다시 인증하지 않아도 클라이언트가 새",
                                "outro": "을 발급받을 수 있도록 설계되었습니다."
                            }
                        }
                    },
                    "overview": {
                        "apiReference": {
                            "afterPatBadge": "또는 둘 다 허용하는 것으로 표시됩니다.",
                            "beforeBotBadge": "API 레퍼런스에서는 각 API가"
                        },
                        "description": "모든 API는 동일한 인증 방식을 사용하며, 여기에서 이를 한데 모아 설명합니다. 사용 가능한 인증 유형은 다음과 같습니다:",
                        "hmacValidation": {
                            "afterLink": "방식을 사용해 호출 주체가 {{platformName}}인지 확인합니다.",
                            "beforeLink": "웹훅 호출을 검증할 때는",
                            "heading": "HMAC 검증"
                        },
                        "serverAuthentication": {
                            "afterBadge": "기반 인증을 사용해 {{platformName}} 호출 시 서버를 인증합니다. 일반적으로 게임 결과 보고처럼 서버 권한이 필요한 API나, 공개 토너먼트 검색처럼 사용자별 데이터가 아닌 정보를 가져오는 API에 사용됩니다.",
                            "afterLink": "모듈은",
                            "heading": "서버 인증"
                        },
                        "userAuthentication": {
                            "afterBadge": "기반 인증을 사용해 사용자를 대신해 {{platformName}} API를 호출합니다. 개인 데이터를 조회하거나 특정 사용자를 위한 작업을 수행하는 API에 사용됩니다.",
                            "afterLink": "모듈은",
                            "heading": "사용자 인증"
                        }
                    }
                },
                "badges": {
                    "assertion": {
                        "description": "어설션은 {{platformName}} OAuth Assertion 플로우에서 사용할 수 있도록 지원되는 ID 공급자가 제공하는 ID 토큰입니다.",
                        "text": "Assertion"
                    },
                    "botAccessToken": {
                        "description": "{{platformName}} API를 호출할 때 서버를 인증할 수 있게 해주는 봇 액세스 토큰입니다.",
                        "expandedText": "봇 액세스 토큰",
                        "text": "BOT"
                    },
                    "hmac": {
                        "description": "HMAC 서명",
                        "text": "HMAC"
                    },
                    "ott": {
                        "description": "일회성 계정 연결 토큰",
                        "text": "OTT",
                        "withValue": "OTT {{ott}}"
                    },
                    "personalAccessToken": {
                        "description": "특정 사용자를 위한 개인 액세스 토큰으로, 해당 사용자를 대신해 {{platformName}} API를 호출할 수 있습니다.",
                        "expandedText": "개인 액세스 토큰(PAT)",
                        "text": "PAT"
                    },
                    "personalRefreshToken": {
                        "description": "개인 리프레시 토큰",
                        "text": "Refresh"
                    },
                    "ssoAccountId": {
                        "description": "SSO 제공업체 계정 ID(예: Steam)",
                        "text": "계정 ID"
                    }
                }
            },
            "gameIntegration": {
                "assignWebhooks": {
                    "cancelGameSession": "게임 세션 취소 웹훅",
                    "createGameSession": "게임 세션 생성 웹훅",
                    "getGameAccount": "게임 계정 가져오기",
                    "getGameSession": "게임 세션 조회 웹훅",
                    "receiveEvents": "이벤트 수신 웹훅",
                    "resolveAccountId": "계정 ID 확인",
                    "subscribeGameSessions": "GameSessions 구독 웹훅"
                },
                "createPlaceholder": {
                    "createButtonText": "게임 연동 생성",
                    "empty": {
                        "heading": "게임 연동 없음",
                        "text": "이 게임에는 게임 연동이 없습니다."
                    },
                    "selectApplicationPlaceholder": "애플리케이션을 선택하세요..."
                },
                "messages": {
                    "integrationCreated": "연동이 생성되었습니다!",
                    "payloadGenerated": "페이로드가 성공적으로 생성되었습니다!",
                    "sandboxConfigured": "샌드박스가 구성되었습니다!",
                    "scoringTested": "점수 테스트가 성공적으로 완료되었습니다!",
                    "webhookTestSuccess": "이 웹훅에서 성공 메시지를 받았습니다!"
                },
                "webhook": {
                    "create": {
                        "heading": "웹훅 생성",
                        "successMessage": "웹훅이 생성되었습니다."
                    },
                    "delete": {
                        "confirmMessage": "이 웹훅을 제거하시겠습니까?",
                        "confirmTitle": "웹훅 제거",
                        "successMessage": "웹훅이 삭제되었습니다."
                    },
                    "fields": {
                        "endpoint": "엔드포인트"
                    },
                    "input": {
                        "placeholder": "웹훅 URL"
                    },
                    "limits": {
                        "maxConcurrentRequests": "최대 동시 요청 수",
                        "maxRequestsPerMinute": "분당 최대 요청 수",
                        "requestTimeoutSeconds": "요청 타임아웃(초)",
                        "successMessage": "웹훅 제한이 업데이트되었습니다."
                    },
                    "selectPlaceholder": "웹훅을 선택하세요..."
                }
            },
            "list": {
                "createApp": "애플리케이션 생성",
                "description": "애플리케이션은 {{platformName}}에서 소프트웨어를 식별하는 수단이며, API에 액세스하는 데 필요한 자격 증명을 받기 위해 필요합니다.",
                "emptyStateText": "새 애플리케이션을 생성하여 시작하세요.",
                "heading": "애플리케이션",
                "manageApplications": "애플리케이션 관리"
            },
            "profileCard": {
                "descriptionPlaceholder": "봇을 설명해주세요..."
            }
        }
    }
}
