sodalive-ios/SodaLive/Sources/I18n/I18n.swift

//
//  I18n.swift
//  SodaLive
//
//  Created by Junie (AI) on 2025/12/17.
//

import Foundation

// MARK: - I18n 네임스페이스
// String Catalog를 사용하지 않는 컨텍스트에서 사용할 하드코딩 맵 기반 i18n.
// 기준 언어 선택은 LanguageHeaderProvider.current("ko"|"en"|"ja").
enum I18n {
    // 채팅방(캐릭터 톡) 관련 문자열
    enum ChatRoom {
        // 잠금된 메시지 다이얼로그
        static var lockedMessageTitle: String {
            pick(ko: "잠금된 메시지", en: "Locked message", ja: "ロックされたメッセージ")
        }

        static func unlockMessageDescription(_ price: Int) -> String {
            pick(
                ko: "이 메시지를 \(price)캔으로 잠금해제 하시겠습니까?",
                en: "Do you want to unlock this message for \(price) cans?",
                ja: "このメッセージを\(price)canで解除しますか？"
            )
        }

        static var unlock: String {
            pick(ko: "잠금해제", en: "Unlock", ja: "アンロック")
        }

        // 대화 초기화 다이얼로그
        static var resetTitle: String {
            pick(ko: "대화 초기화", en: "Reset", ja: "トークをリセット")
        }

        static var resetDescription: String {
            pick(
                ko: "지금까지의 대화가 모두 초기화 되고 새롭게 대화를 시작합니다.",
                en: "All previous messages will be cleared and a new conversation will begin.",
                ja: "これまでの会話がすべて初期化され、新しい会話を開始します。"
            )
        }

        static func resetWithCans(_ cans: Int) -> String {
            pick(
                ko: "\(cans)캔으로 초기화",
                en: "Reset with \(cans) cans",
                ja: "\(cans)canでリセット"
            )
        }
    }

    enum Chat {
        enum Auth {
            static var authenticationError: String {
                pick(
                    ko: "본인인증 중 오류가 발생했습니다.",
                    en: "An error occurred during identity verification.",
                    ja: "本人認証中にエラーが発生しました。"
                )
            }

            static var dialogTitle: String {
                pick(ko: "본인인증", en: "Identity verification", ja: "本人認証")
            }

            static var dialogDescription: String {
                pick(
                    ko: "보이스온의 오픈월드 캐릭터톡은\n청소년 보호를 위해 본인인증한\n성인만 이용이 가능합니다.\n캐릭터톡 서비스를 이용하시려면\n본인인증을 하고 이용해주세요.",
                    en: "VoiceOn Open World Character Talk is available only to adults who complete identity verification for youth protection.\nPlease complete identity verification to use Character Talk.",
                    ja: "VoiceOnオープンワールドキャラクタートークは、青少年保護のため本人認証を完了した成人のみ利用できます。\nキャラクタートークを利用するには本人認証を完了してください。"
                )
            }

            static var goToVerification: String {
                pick(ko: "본인인증 하러가기", en: "Verify identity", ja: "本人認証へ")
            }
        }

        enum Character {
            static var popularSectionTitle: String {
                pick(ko: "인기 캐릭터", en: "Popular characters", ja: "人気キャラクター")
            }

            static var newSectionTitle: String {
                pick(ko: "신규 캐릭터", en: "New characters", ja: "新着キャラクター")
            }

            static var recommendSectionTitle: String {
                pick(ko: "추천 캐릭터", en: "Recommended characters", ja: "おすすめキャラクター")
            }

            static var recentSectionTitle: String {
                pick(ko: "최근 대화한 캐릭터", en: "Recently chatted characters", ja: "最近会話したキャラクター")
            }

            static var newBadge: String {
                pick(ko: "N", en: "N", ja: "N")
            }

            static var typeCharacter: String {
                pick(ko: "캐릭터", en: "Character", ja: "キャラクター")
            }

            static var typeClone: String {
                pick(ko: "클론", en: "Clone", ja: "クローン")
            }

            static var detailTitle: String {
                pick(ko: "캐릭터 정보", en: "Character info", ja: "キャラクター情報")
            }

            static var detailOtherCharactersTitle: String {
                pick(ko: "장르의 다른 캐릭터", en: "Other characters in this genre", ja: "同ジャンルの他キャラクター")
            }

            static func age(_ age: Int) -> String {
                pick(ko: "\(age)세", en: "\(age)y", ja: "\(age)歳")
            }

            static var detailWorldViewTitle: String {
                pick(ko: "[세계관 및 작품 소개]", en: "[Worldview & work introduction]", ja: "[世界観と作品紹介]")
            }

            static var detailOriginalTitle: String {
                pick(ko: "원작", en: "Original work", ja: "原作")
            }

            static var detailOriginalLinkButton: String {
                pick(ko: "원작 보러가기", en: "View original work", ja: "原作を見る")
            }

            static var detailPersonalityTitle: String {
                pick(ko: "[성격 및 특징]", en: "[Personality & traits]", ja: "[性格と特徴]")
            }

            static var detailConversationGuideTitle: String {
                pick(ko: "⚠️ 캐릭터톡 대화 가이드", en: "⚠️ Character Talk guide", ja: "⚠️ キャラクタートークガイド")
            }

            static var detailConversationGuideDescription1: String {
                pick(
                    ko: "보이스온의 오픈월드 캐릭터톡은 대화의 자유도가 높아 대화에 참여하는 당신은 누구든 될 수 있습니다. 세계관 속 연관 캐릭터가 되어 대화를 하거나 완전히 새로운 인물이 되어 캐릭터와 당신만의 스토리를 만들어 갈 수 있습니다.",
                    en: "VoiceOn Open World Character Talk gives you high conversational freedom. You can become a related character in the world or a completely new persona and build your own story with the character.",
                    ja: "VoiceOnオープンワールドキャラクタートークは会話の自由度が高く、世界観の関連キャラクターとして会話したり、まったく新しい人物になってキャラクターとあなただけの物語を作れます。"
                )
            }

            static var detailConversationGuideDescription2: String {
                pick(
                    ko: "오픈월드 캐릭터톡은 캐릭터를 정교하게 설계하였지만, 대화가 어색하거나 불완전할 수도 있습니다.\n대화 도중 캐릭터의 대화가 이상하거나 새로운 캐릭터로 대화를 나누고 싶다면 대화를 초기화 하고 새롭게 캐릭터와 대화를 나눠보세요.",
                    en: "Open World Character Talk is designed carefully, but conversations may still feel awkward or incomplete.\nIf dialogue becomes unnatural or you want to chat as a new character, reset the conversation and start again.",
                    ja: "オープンワールドキャラクタートークは精密に設計されていますが、会話が不自然または不完全になる場合があります。\n会話中に不自然さを感じた場合や新しいキャラクターで会話したい場合は、会話を初期化して新しく始めてください。"
                )
            }

            static var detailChatButton: String {
                pick(ko: "대화하기", en: "Start chat", ja: "会話する")
            }

            static var detailCollapse: String {
                pick(ko: "간략히", en: "Collapse", ja: "簡略表示")
            }

            static var detailExpand: String {
                pick(ko: "더보기", en: "More", ja: "もっと見る")
            }

            enum NewList {
                static var title: String {
                    pick(ko: "신규 캐릭터 전체보기", en: "All new characters", ja: "新着キャラクター一覧")
                }

                static var totalPrefix: String {
                    pick(ko: "전체", en: "Total", ja: "全体")
                }

                static var countUnit: String {
                    pick(ko: "개", en: "", ja: "件")
                }
            }

            enum DetailGallery {
                static func ownership(_ percentage: Int) -> String {
                    pick(ko: "\(percentage)% 보유중", en: "\(percentage)% owned", ja: "\(percentage)%保有中")
                }

                static func totalCount(_ count: Int) -> String {
                    pick(ko: "\(count)개", en: "\(count)", ja: "\(count)件")
                }
            }
        }

        enum Original {
            static var adultBadge: String {
                pick(ko: "19+", en: "19+", ja: "19+")
            }

            static var workIntroductionTitle: String {
                pick(ko: "작품 소개", en: "Work introduction", ja: "作品紹介")
            }

            static var viewOriginalLinksTitle: String {
                pick(ko: "원작 보러 가기", en: "View original links", ja: "原作リンクを見る")
            }

            static var detailInfoTitle: String {
                pick(ko: "상세 정보", en: "Details", ja: "詳細情報")
            }

            static var writerLabel: String {
                pick(ko: "작가", en: "Writer", ja: "作家")
            }

            static var studioLabel: String {
                pick(ko: "제작사", en: "Studio", ja: "制作会社")
            }

            static var originalLabel: String {
                pick(ko: "원작", en: "Original work", ja: "原作")
            }
        }

        enum Talk {
            static var emptyMessage: String {
                pick(ko: "대화 중인 톡이 없습니다", en: "No active chats", ja: "進行中のトークがありません")
            }
        }

        enum Room {
            static var noticeForCharacter: String {
                pick(
                    ko: "보이스온 AI캐릭터톡은 대화의 자유도가 높아 대화에 참여하는 당신은 누구든 될 수 있습니다.\n세계관 속 캐릭터로 대화를 하거나 새로운 인물로 캐릭터와 당신만의 스토리를 만들어보세요.\n※ AI캐릭터톡은 오픈베타 서비스 중이며, 캐릭터의 대화가 어색하거나 불완전할 수 있습니다.",
                    en: "VoiceOn AI Character Talk offers a high degree of conversational freedom.\nTalk as a character in the world or as a new persona and create your own story with the character.\n※ AI Character Talk is in open beta, so responses may be awkward or incomplete.",
                    ja: "VoiceOn AIキャラクタートークは会話の自由度が高く、会話に参加するあなたは誰にでもなれます。\n世界観のキャラクターとして会話したり、新しい人物としてキャラクターとあなただけの物語を作ってみてください。\n※ AIキャラクタートークはオープンベータ中のため、会話が不自然または不完全な場合があります。"
                )
            }

            static var noticeForClone: String {
                pick(
                    ko: "AI Clone은 크리에이터의 정보를 기반으로 대화하지만, 모든 정보를 완벽하게 반영하거나 실제 대화와 일치하지 않을 수 있습니다.",
                    en: "AI Clone chats based on creator information, but may not perfectly reflect all details or match real conversations.",
                    ja: "AI Cloneはクリエイター情報をもとに会話しますが、すべての情報を完全に反映したり実際の会話と一致しない場合があります。"
                )
            }

            static var messagePlaceholder: String {
                pick(ko: "메시지를 입력하세요.", en: "Enter a message.", ja: "メッセージを入力してください。")
            }

            static var resettingMessage: String {
                pick(ko: "대화 초기화 중...", en: "Resetting conversation...", ja: "会話を初期化中...")
            }

            static var unlockImagePrompt: String {
                pick(ko: "눌러서 잠금해제", en: "Tap to unlock", ja: "タップして解除")
            }

            static var typingAccessibilityLabel: String {
                pick(ko: "입력 중", en: "Typing", ja: "入力中")
            }

            static var quotaWaitForFreeNotice: String {
                pick(ko: "기다리면 무료 이용이 가능합니다.", en: "Wait for free usage.", ja: "待てば無料で利用できます。")
            }

            static func quotaPurchaseAction(chatCount: Int) -> String {
                pick(
                    ko: "(채팅 \(chatCount)개) 바로 대화 시작",
                    en: "(\(chatCount) chats) Start now",
                    ja: "(チャット\(chatCount)件) すぐに会話開始"
                )
            }

            static var backgroundSelectionTitle: String {
                pick(ko: "배경 이미지 선택", en: "Select background image", ja: "背景画像を選択")
            }

            static var currentBackground: String {
                pick(ko: "현재 배경", en: "Current background", ja: "現在の背景")
            }

            static var settingsTitle: String {
                pick(ko: "대화 설정", en: "Chat settings", ja: "会話設定")
            }

            static var hideBackgroundImage: String {
                pick(ko: "배경 이미지 끄기", en: "Hide background image", ja: "背景画像をオフ")
            }

            static var changeBackgroundImage: String {
                pick(ko: "배경 이미지 변경", en: "Change background image", ja: "背景画像を変更")
            }

            static var resetConversationTitle: String {
                pick(ko: "대화 초기화", en: "Reset conversation", ja: "会話を初期化")
            }

            static var resetWarningPrefix: String {
                pick(ko: "⚠️ ", en: "⚠️ ", ja: "⚠️ ")
            }

            static var resetWarningDescription: String {
                pick(
                    ko: "지금까지의 대화가 모두 초기화 되고, 이용자가 새로운 캐릭터가 되어 새롭게 대화를 시작합니다.",
                    en: "All previous messages are reset, and you start a new conversation as a new character.",
                    ja: "これまでの会話はすべて初期化され、利用者が新しいキャラクターとなって新しく会話を始めます。"
                )
            }

            static var defaultCharacterName: String {
                pick(ko: "캐릭터", en: "Character", ja: "キャラクター")
            }
        }
    }

    // 검색 관련 문자열
    enum Search {
        // 검색 입력 플레이스홀더: 2글자 이상 안내
        static var placeholderMin2: String {
            pick(
                ko: "검색어를 2글자 이상 입력하세요",
                en: "Enter at least 2 characters",
                ja: "2文字以上で入力してください"
            )
        }

        static var tabUnified: String {
            pick(ko: "통합", en: "All", ja: "統合")
        }

        static var tabCreator: String {
            pick(ko: "채널", en: "Channel", ja: "チャンネル")
        }

        static var tabContent: String {
            pick(ko: "콘텐츠", en: "Content", ja: "コンテンツ")
        }

        static var tabSeries: String {
            pick(ko: "시리즈", en: "Series", ja: "シリーズ")
        }

        static var noResults: String {
            pick(
                ko: "검색 결과가 없습니다.",
                en: "No results found.",
                ja: "検索結果がありません。"
            )
        }

        static var more: String {
            pick(ko: "더보기 >", en: "More >", ja: "もっと見る >")
        }
    }

    enum SearchChannel {
        static var title: String {
            pick(ko: "채널 탐색", en: "Search channels", ja: "チャンネル探索")
        }
    }

    enum NotificationList {
        static var emptyMessage: String {
            pick(ko: "알림이 없습니다.", en: "No notifications.", ja: "通知がありません。")
        }

        static var timestampSeparator: String {
            pick(ko: " · ", en: " · ", ja: " · ")
        }
    }

    enum ContentDetail {
        static var title: String {
            pick(ko: "콘텐츠 상세", en: "Content details", ja: "コンテンツ詳細")
        }

        static var creatorOtherContents: String {
            pick(
                ko: "크리에이터의 다른 콘텐츠",
                en: "More from this creator",
                ja: "クリエイターの他コンテンツ"
            )
        }

        static var themeOtherContents: String {
            pick(
                ko: "테마의 다른 콘텐츠",
                en: "More in this theme",
                ja: "このテーマの他コンテンツ"
            )
        }

        static var pinLimitTitle: String {
            pick(
                ko: "고정 한도 도달",
                en: "Pin limit reached",
                ja: "固定上限到達"
            )
        }
        
        static var preview: String {
            pick(
                ko: "미리듣기",
                en: "Preview",
                ja: "試聴"
            )
        }
        
        static var noPreview: String {
            pick(
                ko: "미리듣기 미지원",
                en: "No Preview",
                ja: "試聴非対応"
            )
        }

        static var pinLimitDesc: String {
            pick(
                ko: "이 콘텐츠를 고정하시겠어요? 채널에 콘텐츠를 최대 3개까지 고정할 수 있습니다. 이 콘텐츠를 고정하면 가장 오래된 콘텐츠가 대체됩니다.",
                en: "Do you want to pin this content? You can pin up to 3 contents in a channel. Pinning this will replace the oldest pinned content.",
                ja: "このコンテンツを固定しますか？チャンネルには最大3件まで固定できます。このコンテンツを固定すると最も古い固定コンテンツが置き換えられます。"
            )
        }

        static var soldOutNotice: String {
            pick(ko: "해당 콘텐츠가 매진되었습니다.", en: "This content is sold out.", ja: "このコンテンツは売り切れです。")
        }

        static var deleteAgreementRequired: String {
            pick(ko: "동의하셔야 삭제할 수 있습니다.", en: "You must agree before deleting.", ja: "同意いただくと削除できます。")
        }

        static var shareLinkCreateFailed: String {
            pick(ko: "공유링크를 생성하지 못했습니다.\n다시 시도해 주세요.", en: "Failed to create a share link.\nPlease try again.", ja: "共有リンクを作成できませんでした。\nもう一度お試しください。")
        }

        static var rentalCompleted: String {
            pick(ko: "대여가 완료되었습니다.", en: "Rental completed.", ja: "レンタルが完了しました。")
        }

        static var purchaseCompleted: String {
            pick(ko: "구매가 완료되었습니다.", en: "Purchase completed.", ja: "購入が完了しました。")
        }

        static var deleteCompleted: String {
            pick(ko: "삭제되었습니다", en: "Deleted.", ja: "削除されました。")
        }

        static var pinCompleted: String {
            pick(ko: "고정되었습니다", en: "Pinned.", ja: "固定されました。")
        }

        static var unpinCompleted: String {
            pick(ko: "해제되었습니다", en: "Unpinned.", ja: "固定解除されました。")
        }

        static var donationMessageRequired: String {
            pick(ko: "함께 보낼 메시지를 입력하세요.", en: "Please enter a message to send together.", ja: "一緒に送るメッセージを入力してください。")
        }

        static func donationCompleted(_ can: Int) -> String {
            pick(ko: "\(can)캔을 후원하셨습니다.", en: "You donated \(can) cans.", ja: "\(can)canを後援しました。")
        }

        enum Info {
            static var share: String {
                pick(ko: "공유", en: "Share", ja: "共有")
            }

            static var donation: String {
                pick(ko: "후원", en: "Donate", ja: "後援")
            }

            static var previewAlertMessage: String {
                pick(ko: "미리듣기 중입니다.\n콘텐츠 구매 후 전체를 감상해 보세요.", en: "You are listening to a preview.\nPurchase this content to listen to the full version.", ja: "現在は試聴中です。\nコンテンツ購入後に全編をお楽しみください。")
            }
        }

        enum Menu {
            static var pinToMyChannel: String {
                pick(ko: "내 채널에 고정", en: "Pin to my channel", ja: "マイチャンネルに固定")
            }

            static var unpinFromMyChannel: String {
                pick(ko: "내 채널에 고정 취소", en: "Unpin from my channel", ja: "マイチャンネルの固定を解除")
            }

            static var edit: String {
                pick(ko: "수정", en: "Edit", ja: "編集")
            }

            static var report: String {
                pick(ko: "신고", en: "Report", ja: "通報")
            }
        }

        enum DeleteDialog {
            static var title: String {
                pick(ko: "콘텐츠 삭제", en: "Delete content", ja: "コンテンツ削除")
            }

            static func confirmQuestion(_ title: String) -> String {
                pick(ko: "[\(title)]을 삭제하시겠습니까?", en: "Do you want to delete [\(title)]?", ja: "[\(title)]を削除しますか？")
            }

            static var irreversibleAcknowledgement: String {
                pick(ko: "삭제된 콘텐츠는 되돌릴 수 없음을 알고 있습니다.", en: "I understand deleted content cannot be restored.", ja: "削除されたコンテンツは元に戻せないことを理解しています。")
            }

            static var purchasedUserNotice: String {
                pick(ko: "콘텐츠를 삭제하더라도 이미 구매한\n사용자는 콘텐츠를 이용할 수 있습니다.", en: "Even if the content is deleted, users who already purchased it can still use it.", ja: "コンテンツを削除しても、すでに購入した\nユーザーは引き続き利用できます。")
            }
        }

        enum ReportDialog {
            static var title: String {
                pick(ko: "콘텐츠 신고", en: "Report content", ja: "コンテンツ通報")
            }

            static var reasons: [String] {
                [
                    reasonHarassment,
                    reasonPrivacy,
                    reasonImpersonation,
                    reasonViolentThreat,
                    reasonChildAbuse,
                    reasonHateSpeech,
                    reasonSpamScam
                ]
            }

            static var reasonHarassment: String { pick(ko: "괴롭힘 및 사이버 폭력", en: "Harassment and cyberbullying", ja: "嫌がらせ・サイバーいじめ") }
            static var reasonPrivacy: String { pick(ko: "개인정보 침해", en: "Privacy violation", ja: "個人情報の侵害") }
            static var reasonImpersonation: String { pick(ko: "명의도용", en: "Impersonation", ja: "なりすまし") }
            static var reasonViolentThreat: String { pick(ko: "폭력적 위협", en: "Violent threats", ja: "暴力的な脅迫") }
            static var reasonChildAbuse: String { pick(ko: "아동학대", en: "Child abuse", ja: "児童虐待") }
            static var reasonHateSpeech: String { pick(ko: "보호대상 집단에 대한 증오심 표현", en: "Hate speech against protected groups", ja: "保護対象集団へのヘイト表現") }
            static var reasonSpamScam: String { pick(ko: "스팸 및 사기", en: "Spam and scams", ja: "スパム・詐欺") }

            static var notice: String {
                pick(ko: "신고한 콘텐츠를 관리자가 확인 후, 서비스정책을\n위반한 경우 삭제 조치할 예정입니다.", en: "After review by administrators, reported content that violates service policy will be removed.", ja: "通報されたコンテンツは管理者が確認し、\nサービス方針違反の場合は削除対応されます。")
            }

            static var reportAction: String {
                pick(ko: "신고", en: "Report", ja: "通報")
            }
        }

        enum Comment {
            static var title: String { pick(ko: "댓글", en: "Comments", ja: "コメント") }
            static var secretComment: String { pick(ko: "비밀댓글", en: "Secret comment", ja: "秘密コメント") }
            static var inputPlaceholder: String { pick(ko: "댓글을 입력해 보세요.", en: "Enter a comment.", ja: "コメントを入力してください。") }
            static var replyTitle: String { pick(ko: "답글", en: "Replies", ja: "返信") }
            static var writeReply: String { pick(ko: "답글 쓰기", en: "Write reply", ja: "返信を書く") }
            static func replyCount(_ count: Int) -> String { pick(ko: "답글 \(count)개", en: "\(count) replies", ja: "返信\(count)件") }
            static var edit: String { pick(ko: "수정", en: "Edit", ja: "編集") }
            static var noChanges: String { pick(ko: "변경사항이 없습니다.", en: "No changes.", ja: "変更事項がありません。") }
            static var inputContent: String { pick(ko: "내용을 입력하세요.", en: "Please enter content.", ja: "内容を入力してください。") }
        }

        enum LimitedEdition {
            static var title: String { pick(ko: "한정판", en: "Limited edition", ja: "限定版") }
            static var remainingCount: String { pick(ko: "잔여수량", en: "Remaining", ja: "残り数量") }
            static var buyers: String { pick(ko: "구매자", en: "Buyers", ja: "購入者") }
        }

        enum Mosaic {
            static var adultRestrictionNotice: String {
                pick(ko: "본 콘텐츠는 만 19세 미만의 청소년이\n이용할 수 없습니다.\n본인인증 후 콘텐츠를 이용해 주세요.", en: "This content is not available to users under 19.\nPlease verify your identity to access this content.", ja: "このコンテンツは19歳未満の方は\n利用できません。\n本人認証後にご利用ください。")
            }

            static var verifyIdentity: String {
                pick(ko: "본인인증", en: "Verify identity", ja: "本人認証")
            }
        }

        enum OtherContent {
            static func preparingMessage(_ title: String) -> String {
                pick(ko: "\(title)를 준비중입니다.\n조금만 기다려주세요.", en: "\(title) is being prepared.\nPlease wait a little longer.", ja: "\(title)を準備中です。\nしばらくお待ちください。")
            }
        }

        enum Navigation {
            static var previousEpisode: String { pick(ko: "이전화", en: "Previous", ja: "前話") }
            static var nextEpisode: String { pick(ko: "다음화", en: "Next", ja: "次話") }
        }

        enum Purchase {
            static var withWon: String { pick(ko: "원으로", en: " KRW", ja: "ウォンで") }
            static var withCan: String { pick(ko: "캔으로", en: " cans", ja: "canで") }
            static var wonUnit: String { pick(ko: "원", en: " KRW", ja: "ウォン") }
        }

        enum OrderDialog {
            static var rent: String { pick(ko: "대여", en: "Rent", ja: "レンタル") }
            static var rentPeriod: String { pick(ko: "(이용기간 5일)", en: "(5-day access)", ja: "(利用期間5日)") }
            static var buy: String { pick(ko: "소장", en: "Buy", ja: "購入") }
            static var buyPeriod: String { pick(ko: "(서비스 종료시까지)", en: "(Until service end)", ja: "(サービス終了まで)") }
        }

        enum OrderConfirmDialog {
            static var title: String { pick(ko: "구매확인", en: "Purchase confirmation", ja: "購入確認") }
            static var rentQuestion: String { pick(ko: "콘텐츠를 대여하시겠습니까?", en: "Do you want to rent this content?", ja: "このコンテンツをレンタルしますか？") }
            static var buyQuestion: String { pick(ko: "콘텐츠를 소장하시겠습니까?", en: "Do you want to buy this content?", ja: "このコンテンツを購入しますか？") }
            static var deductionNotice: String { pick(ko: "아래 금액이 차감됩니다.", en: "The amount below will be deducted.", ja: "下記金額が差し引かれます。") }
        }

        enum DonationDialog {
            static var title: String { pick(ko: "후원하기", en: "Donate", ja: "後援する") }
            static var charge: String { pick(ko: "충전", en: "Charge", ja: "チャージ") }
            static var minimumOneCanPlaceholder: String { pick(ko: "1캔 이상 입력하세요", en: "Enter 1 can or more", ja: "1can以上入力してください") }
            static var minimumTenCanPlaceholder: String { pick(ko: "10캔 이상 입력하세요", en: "Enter 10 cans or more", ja: "10can以上入力してください") }
            static func messagePlaceholder(isSecret: Bool, limit: Int) -> String {
                let koPrefix = isSecret ? "비밀 " : ""
                let enPrefix = isSecret ? "secret " : ""
                let jaPrefix = isSecret ? "秘密" : ""

                return pick(
                    ko: "함께 보낼 \(koPrefix)메시지 입력(최대 \(limit)자)",
                    en: "Enter a \(enPrefix)message (max \(limit) chars)",
                    ja: "一緒に送る\(jaPrefix)メッセージを入力（最大\(limit)文字）"
                )
            }
            static var donateAction: String { pick(ko: "후원하기", en: "Donate", ja: "後援する") }
        }
    }
    enum ContentBox {
        static var title: String {
            pick(ko: "내 보관함", en: "My Library", ja: "マイライブラリ")
        }

        static var tabOrderList: String {
            pick(ko: "구매목록", en: "Purchases", ja: "購入一覧")
        }

        static var tabPlaylist: String {
            pick(ko: "재생목록", en: "Playlists", ja: "プレイリスト")
        }
    }

    enum Content {
        enum List {
            static var title: String {
                pick(ko: "콘텐츠 전체보기", en: "All content", ja: "コンテンツ一覧")
            }

            static var createNewContentAction: String {
                pick(ko: "새로운 콘텐츠 등록하기", en: "Register new content", ja: "新しいコンテンツを登録する")
            }
        }

        enum All {
            static var title: String {
                pick(ko: "콘텐츠 전체", en: "All content", ja: "コンテンツ全体")
            }

            static var freeTitle: String {
                pick(ko: "무료 콘텐츠 전체", en: "All free content", ja: "無料コンテンツ全体")
            }

            static var pointRentalTitle: String {
                pick(ko: "포인트 대여 전체", en: "All point-rental content", ja: "ポイントレンタル全体")
            }
        }

        enum New {
            static var title: String {
                pick(ko: "최신 콘텐츠", en: "Latest content", ja: "最新コンテンツ")
            }

            static var freeTitle: String {
                pick(ko: "최신 무료 콘텐츠", en: "Latest free content", ja: "最新無料コンテンツ")
            }

            static var recentTwoWeeksNotice: String {
                pick(
                    ko: "※ 최근 2주간 등록된 새로운 콘텐츠 입니다.",
                    en: "※ New content registered in the last 2 weeks.",
                    ja: "※ 最近2週間で登録された新しいコンテンツです。"
                )
            }
        }

        enum Ranking {
            static var title: String {
                pick(ko: "인기 콘텐츠", en: "Popular content", ja: "人気コンテンツ")
            }

            static var weeklyUpdateNotice: String {
                pick(
                    ko: "※ 인기 콘텐츠의 순위는 매주 업데이트됩니다.",
                    en: "※ Popular content rankings are updated weekly.",
                    ja: "※ 人気コンテンツの順位は毎週更新されます。"
                )
            }
        }

        enum Sort {
            static var newest: String {
                pick(ko: "최신순", en: "Newest", ja: "新着順")
            }

            static var popularity: String {
                pick(ko: "인기순", en: "Most popular", ja: "人気順")
            }

            static var priceHigh: String {
                pick(ko: "높은 가격순", en: "Highest price", ja: "価格の高い順")
            }

            static var priceLow: String {
                pick(ko: "낮은 가격순", en: "Lowest price", ja: "価格の低い順")
            }
        }

        enum Count {
            static var totalPrefix: String {
                pick(ko: "전체", en: "Total", ja: "全体")
            }

            static var countUnit: String {
                pick(ko: "개", en: "", ja: "件")
            }
        }

        enum Status {
            static var owned: String {
                pick(ko: "소장중", en: "Owned", ja: "所持中")
            }

            static var rented: String {
                pick(ko: "대여중", en: "Renting", ja: "レンタル中")
            }

            static var soldOut: String {
                pick(ko: "Sold Out", en: "Sold out", ja: "売り切れ")
            }
        }

        enum Playback {
            static var playFailed: String {
                pick(
                    ko: "오류가 발생했습니다. 다시 시도해 주세요.",
                    en: "An error occurred. Please try again.",
                    ja: "エラーが発生しました。もう一度お試しください。"
                )
            }
        }

        enum Banner {
            static var loadFailed: String {
                pick(
                    ko: "배너를 불러오지 못했습니다. 다시 시도해 주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                    en: "Failed to load banners. Please try again.\nIf the issue persists, contact customer support.",
                    ja: "バナーを読み込めませんでした。もう一度お試しください。\n問題が続く場合はカスタマーサポートにお問い合わせください。"
                )
            }
        }

        enum Playlist {
            static var createNewAction: String { pick(ko: "+ 새 재생목록 만들기", en: "+ Create new playlist", ja: "+ 新しいプレイリストを作成") }
            static var emptyTitle: String { pick(ko: "재생목록이 비어있습니다.", en: "Your playlist is empty.", ja: "プレイリストが空です。") }
            static var emptyDescription: String { pick(ko: "자주 듣는 콘텐츠를\n재생목록으로 만들어 보세요.", en: "Create a playlist with\nyour frequently listened content.", ja: "よく聴くコンテンツで\nプレイリストを作ってみましょう。") }
            static var totalLabel: String { pick(ko: "전체", en: "Total", ja: "全体") }
            static func totalCount(_ count: Int) -> String { pick(ko: "총 \(count)개", en: "Total \(count)", ja: "全\(count)件") }
            static func itemCount(_ count: Int) -> String { pick(ko: "총 \(count)개", en: "Total \(count)", ja: "全\(count)件") }
            static var createTitle: String { pick(ko: "새 재생목록 만들기", en: "Create new playlist", ja: "新しいプレイリストを作成") }
            static var createSave: String { pick(ko: "저장", en: "Save", ja: "保存") }
            static var modifyTitle: String { pick(ko: "재생목록 수정", en: "Edit playlist", ja: "プレイリストを編集") }
            static var modifyAction: String { pick(ko: "수정", en: "Edit", ja: "編集") }
            static var titleLabel: String { pick(ko: "재생목록 제목", en: "Playlist title", ja: "プレイリストタイトル") }
            static var descriptionLabel: String { pick(ko: "재생목록 설명을 입력해 주세요", en: "Please enter a playlist description", ja: "プレイリストの説明を入力してください") }
            static var addContentAction: String { pick(ko: "새로운 콘텐츠 추가/제거", en: "Add/remove content", ja: "新しいコンテンツを追加・削除") }
            static var close: String { pick(ko: "닫기", en: "Close", ja: "閉じる") }
            static func selectionCount(_ count: Int) -> String { pick(ko: "\(count)개", en: "\(count)", ja: "\(count)件") }
            static func createdDate(_ date: String) -> String { pick(ko: "만든 날짜 \(date)", en: "Created on \(date)", ja: "作成日 \(date)") }
            static func contentCount(_ count: Int) -> String { pick(ko: "\(count)개", en: "\(count)", ja: "\(count)件") }
            static var play: String { pick(ko: "재생", en: "Play", ja: "再生") }
            static var shuffle: String { pick(ko: "셔플", en: "Shuffle", ja: "シャッフル") }
            static var titleValidation: String { pick(ko: "제목을 3자 이상 입력하세요", en: "Enter at least 3 characters for the title.", ja: "タイトルを3文字以上入力してください") }
            static var contentValidation: String { pick(ko: "콘텐츠를 1개 이상 추가하세요", en: "Add at least one content item.", ja: "コンテンツを1件以上追加してください") }
        }
    }

    enum CharacterDetailGallery {
        static var purchaseConfirmTitle: String {
            pick(ko: "구매 확인", en: "Confirmation", ja: "購入確認")
        }

        static var purchaseConfirmDescription: String {
            pick(
                ko: "선택한 이미지를 구매하시겠습니까?", en: "Buy the selected image?",
                ja: "選択した画像を購入しますか？"
            )
        }

        static func purchaseWithCans(_ cans: Int) -> String {
            pick(
                ko: "\(cans)캔으로 구매",
                en: "Purchase for \(cans) cans",
                ja: "\(cans)CANで購入"
            )
        }
    }
    enum Time {
        static var justNow: String {
            pick(ko: "방금 전", en: "Just now", ja: "たった今")
        }

        static func minutesAgo(_ minutes: Int) -> String {
            pick(
                ko: "\(minutes)분 전",
                en: "\(minutes) minute\(minutes == 1 ? "" : "s") ago",
                ja: "\(minutes)分前"
            )
        }

        static func hoursAgo(_ hours: Int) -> String {
            pick(
                ko: "\(hours)시간 전",
                en: "\(hours) hour\(hours == 1 ? "" : "s") ago",
                ja: "\(hours)時間前"
            )
        }

        static func daysAgo(_ days: Int) -> String {
            pick(
                ko: "\(days)일 전",
                en: "\(days) day\(days == 1 ? "" : "s") ago",
                ja: "\(days)日前"
            )
        }

        static func minutesAgoCompact(_ minutes: Int) -> String {
            pick(
                ko: "\(minutes)분전",
                en: "\(minutes)m ago",
                ja: "\(minutes)分前"
            )
        }

        static func hoursAgoCompact(_ hours: Int) -> String {
            pick(
                ko: "\(hours)시간전",
                en: "\(hours)h ago",
                ja: "\(hours)時間前"
            )
        }

        static func daysAgoCompact(_ days: Int) -> String {
            pick(
                ko: "\(days)일전",
                en: "\(days)d ago",
                ja: "\(days)日前"
            )
        }

        static func monthsAgo(_ months: Int) -> String {
            pick(
                ko: "\(months)개월 전",
                en: "\(months) month\(months == 1 ? "" : "s") ago",
                ja: "\(months)か月前"
            )
        }

        static func yearsAgo(_ years: Int) -> String {
            pick(
                ko: "\(years)년 전",
                en: "\(years) year\(years == 1 ? "" : "s") ago",
                ja: "\(years)年前"
            )
        }
    }
    enum Common {
        static var viewAll: String { pick(ko: "전체보기", en: "View all", ja: "すべて見る") }

        // 기본 샘플들
        static var apply: String { pick(ko: "적용", en: "Save", ja: "適用") }
        static var confirm: String { pick(ko: "확인", en: "Confirm", ja: "確認") }
        static var cancel: String { pick(ko: "취소", en: "Cancel", ja: "キャンセル") }
        static var yes: String { pick(ko: "예", en: "Yes", ja: "はい") }
        static var no: String { pick(ko: "아니오", en: "No", ja: "いいえ") }
        // 공통 액션/라벨
        static var delete: String { pick(ko: "삭제", en: "Delete", ja: "削除") }
        static var commentDeleteTitle: String { pick(ko: "댓글 삭제", en: "Delete comment", ja: "コメントを削除") }
        static var postDeleteTitle: String { pick(ko: "게시물 삭제", en: "Delete post", ja: "投稿を削除") }

        // 설정
        static var settings: String { pick(ko: "설정", en: "Settings", ja: "設定") }
        static var alertTitle: String { pick(ko: "알림", en: "Notice", ja: "お知らせ") }
        static var noticeTitle: String { pick(ko: "안내", en: "Notice", ja: "お知らせ") }
        static var pointGrantTitle: String { pick(ko: "포인트 지급", en: "Points granted", ja: "ポイント付与") }

        static var commonError: String {
            pick(
                ko: "다시 시도해 주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                en: "try again.\nIf the issue persists, contact customer support.",
                ja: "恐れ入りますが再度お試しください。\n問題が続く場合はカスタマーセンターにお問い合わせください。"
            )
        }

        static var roulette1: String { pick(ko: "룰렛 1", en: "Roulette 1", ja: "ルーレット 1") }
        static var roulette2: String { pick(ko: "룰렛 2", en: "Roulette 2", ja: "ルーレット 2") }
        static var roulette3: String { pick(ko: "룰렛 3", en: "Roulette 3", ja: "ルーレット 3") }

        static var confirmDeleteQuestion: String { pick(ko: "삭제하시겠습니까?", en: "Are you sure you want to delete?", ja: "削除しますか？") }

        static var followers: String { pick(ko: "팔로워", en: "Followers", ja: "フォロワー") }
        static var latestContent: String { pick(ko: "최신 콘텐츠", en: "New", ja: "最新コンテンツ") }
        static var openScheduled: String { pick(ko: "오픈예정", en: "Scheduled to open", ja: "公開予定") }
        static var points: String { pick(ko: "포인트", en: "Points", ja: "ポイント") }
    }

    enum Audition {
        static var title: String {
            pick(ko: "오디션", en: "Audition", ja: "オーディション")
        }

        static var defaultTitle: String {
            pick(ko: "보이스온", en: "VoiceOn", ja: "ボイスオン")
        }

        enum List {
            static var usageGuide: String {
                pick(
                    ko: "보이스온 오디션 이용방법",
                    en: "How to use VoiceOn Audition",
                    ja: "ボイスオンオーディション利用方法"
                )
            }

            static var detail: String {
                pick(ko: "자세히>", en: "Details >", ja: "詳しく >")
            }

            static var onStatus: String {
                pick(ko: " ON", en: " ON", ja: " ON")
            }

            static var offStatus: String {
                pick(ko: " OFF", en: " OFF", ja: " OFF")
            }

            static func totalCount(_ count: Int) -> String {
                pick(
                    ko: "총 \(count)개",
                    en: "Total \(count)",
                    ja: "全\(count)件"
                )
            }
        }

        enum ApplyMethod {
            static var title: String {
                pick(ko: "오디션 지원방식", en: "Audition application method", ja: "オーディション応募方法")
            }

            static var fileUpload: String {
                pick(ko: "파일 업로드", en: "Upload file", ja: "ファイルアップロード")
            }

            static var recordNow: String {
                pick(ko: "바로 녹음", en: "Record now", ja: "今すぐ録音")
            }

            static var fileFormatNotice: String {
                pick(
                    ko: "※ 파일은 mp3, aac만 업로드 가능",
                    en: "※ Only mp3 and aac files can be uploaded",
                    ja: "※ ファイルはmp3、aacのみアップロード可能"
                )
            }
        }

        enum Apply {
            static var title: String {
                pick(ko: "오디션 지원", en: "Apply for audition", ja: "オーディション応募")
            }

            static var recordingFile: String {
                pick(ko: "녹음파일", en: "Recorded file", ja: "録音ファイル")
            }

            static var contact: String {
                pick(ko: "연락처", en: "Contact", ja: "連絡先")
            }

            static var contactPlaceholder: String {
                pick(
                    ko: "합격시 받을 연락처를 남겨주세요",
                    en: "Enter contact information to receive if selected",
                    ja: "合格時に受け取る連絡先を入力してください"
                )
            }

            static var recordedVoiceFileName: String {
                pick(ko: "내 녹음파일", en: "My recording", ja: "自分の録音ファイル")
            }

            static var privacyAgreement: String {
                pick(
                    ko: "보이스온 오디오 드라마 오디션 합격시 개인 연락을 위한 개인 정보(연락처) 수집 및 활용에 동의합니다.\n오디션 지원자는 개인정보 수집 및 활용 동의에 거부할 권리가 있으며 비동의시 오디션 지원은 취소 됩니다.",
                    en: "I agree to the collection and use of personal information (contact) for personal contact if selected for the VoiceOn audio drama audition.\nApplicants have the right to refuse consent to the collection and use of personal information, and if they do not consent, the audition application will be canceled.",
                    ja: "ボイスオンオーディオドラマオーディション合格時の個別連絡のため、個人情報（連絡先）の収集および利用に同意します。\n応募者は個人情報の収集および利用への同意を拒否する権利があり、同意しない場合はオーディション応募が取り消されます。"
                )
            }

            static var submit: String {
                pick(ko: "오디션 지원하기", en: "Submit audition application", ja: "オーディションに応募する")
            }

            static var apply: String {
                pick(ko: "오디션 지원", en: "Apply for audition", ja: "オーディション応募")
            }

            static var reapply: String {
                pick(ko: "오디션 재지원", en: "Reapply for audition", ja: "オーディション再応募")
            }

            static var requireAgreement: String {
                pick(
                    ko: "연락처 수집 및 활용에 동의하셔야 오디션 지원이 가능합니다.",
                    en: "You must agree to the collection and use of contact information to apply for the audition.",
                    ja: "連絡先の収集および利用に同意すると、オーディションに応募できます。"
                )
            }

            static var reapplyNoticeTitle: String {
                pick(ko: "재지원 안내", en: "Reapply notice", ja: "再応募の案内")
            }

            static var reapplyNoticeDesc: String {
                pick(
                    ko: "재지원 시 이전 지원 내역은 삭제되며 받은 투표수는 무효 처리됩니다.",
                    en: "When you reapply, your previous application history is deleted and received votes are invalidated.",
                    ja: "再応募すると、以前の応募履歴は削除され、受け取った投票数は無効になります。"
                )
            }

            static var authRequiredTitle: String {
                pick(ko: "- 본인인증 -", en: "- Identity verification -", ja: "- 本人認証 -")
            }

            static var authRequiredDesc: String {
                pick(
                    ko: "마이페이지에서 '본인인증'을 하고 다시 오디션에 지원해 주세요.",
                    en: "Please complete 'Identity Verification' in My Page and apply for the audition again.",
                    ja: "マイページで「本人認証」を行ってから、もう一度オーディションに応募してください。"
                )
            }

            static var invalidContact: String {
                pick(
                    ko: "잘못된 연락처 입니다.\n다시 입력해 주세요.",
                    en: "Invalid contact information.\nPlease enter it again.",
                    ja: "連絡先が正しくありません。\nもう一度入力してください。"
                )
            }

            static var invalidRecordingFile: String {
                pick(
                    ko: "잘못된 녹음 파일 입니다.\n다시 선택해 주세요.",
                    en: "Invalid recording file.\nPlease select it again.",
                    ja: "録音ファイルが正しくありません。\nもう一度選択してください。"
                )
            }

            static var fileLoadFailed: String {
                pick(
                    ko: "오디오 파일을 불러오지 못했습니다.\n다시 선택해 주세요",
                    en: "Could not load the audio file.\nPlease select it again.",
                    ja: "オーディオファイルを読み込めませんでした。\nもう一度選択してください。"
                )
            }

            static var applyFailed: String {
                pick(
                    ko: "오디션 지원을 완료하지 못했습니다.\n다시 시도해 주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                    en: "Could not complete the audition application.\nPlease try again.\nIf the problem persists, please contact customer support.",
                    ja: "オーディション応募を完了できませんでした。\nもう一度お試しください。\n問題が続く場合はカスタマーサポートにお問い合わせください。"
                )
            }
        }

        enum Recording {
            static var title: String {
                pick(ko: "오디션 녹음", en: "Audition recording", ja: "オーディション録音")
            }

            static var recordAgain: String {
                pick(ko: "다시 녹음", en: "Record again", ja: "再録音")
            }

            static var recordComplete: String {
                pick(ko: "녹음완료", en: "Recording complete", ja: "録音完了")
            }

            static var createFileFailed: String {
                pick(
                    ko: "녹음파일을 생성하지 못했습니다.\n다시 시도해 주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                    en: "Could not create the recording file.\nPlease try again.\nIf the problem persists, please contact customer support.",
                    ja: "録音ファイルを作成できませんでした。\nもう一度お試しください。\n問題が続く場合はカスタマーサポートにお問い合わせください。"
                )
            }
        }

        enum Detail {
            static var informationTitle: String {
                pick(ko: "오디션 정보", en: "Audition information", ja: "オーディション情報")
            }

            static var characterTitle: String {
                pick(ko: "오디션 캐릭터", en: "Audition character", ja: "オーディションキャラクター")
            }

            static var viewOriginalWork: String {
                pick(ko: "원작 보러가기", en: "View original work", ja: "原作を見る")
            }

            static var checkScript: String {
                pick(ko: "오디션 대본 확인", en: "Check audition script", ja: "オーディション台本を確認")
            }

            static var characterInfo: String {
                pick(ko: "오디션 캐릭터 정보", en: "Audition character info", ja: "オーディションキャラクター情報")
            }

            static var noApplicants: String {
                pick(ko: "지원자가 없습니다.", en: "No applicants.", ja: "応募者がいません。")
            }

            static var participants: String {
                pick(ko: "참여자", en: "Participants", ja: "参加者")
            }

            static var personUnit: String {
                pick(ko: "명", en: "people", ja: "名")
            }

            static var sortNewest: String {
                pick(ko: "최신순", en: "Newest", ja: "新着順")
            }

            static var sortLikes: String {
                pick(ko: "좋아요순", en: "Most liked", ja: "いいね順")
            }

            static var recruiting: String {
                pick(ko: "모집중", en: "Open", ja: "募集中")
            }

            static var recruitmentClosed: String {
                pick(ko: "모집완료", en: "Closed", ja: "募集終了")
            }
        }

        enum Vote {
            static var cheerTitle: String {
                pick(ko: "[오디션 응원]", en: "[Audition cheer]", ja: "[オーディション応援]")
            }

            static var cheerDescription: String {
                pick(
                    ko: "오디션을 응원하셨습니다\n(무료응원 : 1계정당 1일 1회)\n1캔으로 추가 응원을 해보세요.",
                    en: "You cheered for this audition.\n(Free cheer: once per account per day)\nTry sending an additional cheer with 1 can.",
                    ja: "オーディションを応援しました。\n（無料応援：1アカウント1日1回）\n1canで追加応援してみましょう。"
                )
            }

            static var limitTitle: String {
                pick(ko: "[오늘 응원 제한]", en: "[Today's cheer limit]", ja: "[本日の応援制限]")
            }

            static var limitDescription: String {
                pick(
                    ko: "오늘 응원은 여기까지!\n하루 최대 10회까지 이용이 가능합니다.\n내일 다시 이용해주세요.",
                    en: "That's all for today's cheers!\nYou can use it up to 10 times a day.\nPlease try again tomorrow.",
                    ja: "本日の応援はここまでです！\n1日最大10回まで利用できます。\n明日またご利用ください。"
                )
            }

            static var unknownError: String {
                pick(
                    ko: "알 수 없는 오류가 발생했습니다. 다시 시도해 주세요.",
                    en: "An unknown error occurred. Please try again.",
                    ja: "不明なエラーが発生しました。もう一度お試しください。"
                )
            }
        }

        enum Sound {
            static var playbackFailed: String {
                pick(
                    ko: "오류가 발생했습니다. 다시 시도해 주세요.",
                    en: "An error occurred. Please try again.",
                    ja: "エラーが発生しました。もう一度お試しください。"
                )
            }
        }
    }

    enum Report {
        static var cheersReportTitle: String {
            pick(ko: "응원글 신고", en: "Report cheer post", ja: "応援投稿を通報")
        }

        static var postReportTitle: String {
            pick(ko: "게시물 신고", en: "Report post", ja: "投稿通報")
        }

        static var reportAction: String {
            pick(ko: "신고", en: "Report", ja: "報告する")
        }

        static var cheersReasons: [String] {
            [
                cheersReasonSpam,
                cheersReasonChildAbuse,
                cheersReasonHateOrViolence,
                cheersReasonTerrorism,
                cheersReasonHarassment,
                cheersReasonSelfHarm,
                cheersReasonMisinformation
            ]
        }

        static var userReasons: [String] {
            [
                userReasonHarassment,
                userReasonPrivacy,
                userReasonImpersonation,
                userReasonThreat,
                userReasonChildAbuse,
                userReasonHate,
                userReasonSpamFraud,
                userReasonNone
            ]
        }

        static var cheersReasonSpam: String {
            pick(
                ko: "원치 않는 상업성 콘텐츠 또는 스팸",
                en: "Unwanted commercial content or spam",
                ja: "望まない商業コンテンツまたはスパム"
            )
        }

        static var cheersReasonChildAbuse: String {
            pick(ko: "아동 학대", en: "Child abuse", ja: "児童虐待")
        }

        static var cheersReasonHateOrViolence: String {
            pick(
                ko: "증오심 표현 또는 노골적인 폭력",
                en: "Hate speech or graphic violence",
                ja: "憎悪表現または過度な暴力表現"
            )
        }

        static var cheersReasonTerrorism: String {
            pick(ko: "테러 조장", en: "Promotion of terrorism", ja: "テロ助長")
        }

        static var cheersReasonHarassment: String {
            pick(ko: "희롱 또는 괴롭힘", en: "Harassment or bullying", ja: "嫌がらせまたはいじめ")
        }

        static var cheersReasonSelfHarm: String {
            pick(ko: "자살 또는 자해", en: "Suicide or self-harm", ja: "自殺または自傷行為")
        }

        static var cheersReasonMisinformation: String {
            pick(ko: "잘못된 정보", en: "Misinformation", ja: "誤情報")
        }

        static var userReasonHarassment: String {
            pick(ko: "괴롭힘 및 사이버 폭력", en: "Harassment and cyberbullying", ja: "嫌がらせとサイバー暴力")
        }

        static var userReasonPrivacy: String {
            pick(ko: "개인정보 침해", en: "Privacy violation", ja: "プライバシー侵害")
        }

        static var userReasonImpersonation: String {
            pick(ko: "명의 도용", en: "Impersonation", ja: "なりすまし")
        }

        static var userReasonThreat: String {
            pick(ko: "폭력적 위협", en: "Violent threats", ja: "暴力的な脅迫")
        }

        static var userReasonChildAbuse: String {
            pick(ko: "아동 학대", en: "Child abuse", ja: "児童虐待")
        }

        static var userReasonHate: String {
            pick(ko: "보호 대상 집단에 대한 증오심 표현", en: "Hate speech toward protected groups", ja: "保護対象グループへの憎悪表現")
        }

        static var userReasonSpamFraud: String {
            pick(ko: "스팸 및 사기", en: "Spam and fraud", ja: "スパムと詐欺")
        }

        static var userReasonNone: String {
            pick(ko: "나에게 해당하는 문제 없음", en: "None of these apply", ja: "該当する問題なし")
        }

        static var profilePhotoReportTitle: String {
            pick(ko: "프로필 사진 신고", en: "Report profile photo", ja: "プロフィール写真を通報")
        }

        static var profilePhotoReportDescription: String {
            pick(
                ko: "신고제도를 남용할 경우, 계정에 제약이 있을 수 있습니다.\n프로필 사진을 신고하시겠습니까?",
                en: "Abusing the reporting system may restrict your account.\nDo you want to report this profile photo?",
                ja: "通報制度を乱用した場合、アカウントに制約がかかる可能性があります。\nプロフィール写真を通報しますか？"
            )
        }

        static var userReportTitle: String {
            pick(ko: "사용자 신고", en: "Report user", ja: "ユーザーを通報")
        }

        static var userReportAction: String {
            pick(ko: "사용자 신고하기", en: "Report user", ja: "ユーザーを通報")
        }

        static var profileReportAction: String {
            pick(ko: "프로필 신고하기", en: "Report profile", ja: "プロフィールを通報")
        }

        static var blockUserAction: String {
            pick(ko: "사용자 차단하기", en: "Block user", ja: "ユーザーをブロック")
        }

        static var unblockUserAction: String {
            pick(ko: "사용자 차단해제", en: "Unblock user", ja: "ユーザーのブロックを解除")
        }

        static var profileReportReason: String {
            pick(ko: "프로필 신고", en: "Report profile", ja: "プロフィールを通報")
        }

        static var reasons: [String] {
            [
                reasonSpam,
                reasonAdult,
                reasonChildAbuse,
                reasonHateOrViolence,
                reasonTerrorism,
                reasonHarassment,
                reasonSelfHarm,
                reasonMisinformation
            ]
        }

        static var reasonSpam: String {
            pick(
                ko: "원치 않는 상업성 콘텐츠 또는 스팸",
                en: "Unwanted commercial content or spam",
                ja: "望まない商業コンテンツまたはスパム"
            )
        }

        static var reasonAdult: String {
            pick(
                ko: "포르노 또는 음란물",
                en: "Pornography or sexually explicit content",
                ja: "ポルノまたはわいせつ物"
            )
        }

        static var reasonChildAbuse: String {
            pick(ko: "아동 학대", en: "Child abuse", ja: "児童虐待")
        }

        static var reasonHateOrViolence: String {
            pick(
                ko: "증오심 표현 또는 노골적인 폭력",
                en: "Hate speech or graphic violence",
                ja: "憎悪表現または過度な暴力表現"
            )
        }

        static var reasonTerrorism: String {
            pick(ko: "테러 조장", en: "Promotion of terrorism", ja: "テロ助長")
        }

        static var reasonHarassment: String {
            pick(ko: "괴롭힘 또는 폭력", en: "Harassment or violence", ja: "嫌がらせまたは暴力")
        }

        static var reasonSelfHarm: String {
            pick(ko: "자살 또는 자해", en: "Suicide or self-harm", ja: "自殺または自傷行為")
        }

        static var reasonMisinformation: String {
            pick(ko: "잘못된 정보", en: "Misinformation", ja: "誤情報")
        }
    }

    enum Splash {
        static var tagline: String {
            pick(
                ko: "목소리로 만나는 새로운 세계",
                en: "A new world you meet by voice",
                ja: "声でつながる新しいワールド"
            )
        }

        static var brandName: String {
            pick(ko: "소다라이브", en: "SodaLive", ja: "ソーダライブ")
        }

        static var maintenanceTitle: String {
            pick(ko: "안내", en: "Notice", ja: "お知らせ")
        }

        static var maintenanceDesc: String {
            pick(
                ko: "서비스 점검중입니다.", en: "Service Under Maintenance",
                ja: "ただいまメンテナンス中です。"
            )
        }

        static var updateTitle: String {
            pick(ko: "업데이트", en: "Update", ja: "アップデート")
        }

        static var updateDesc: String {
            pick(
                ko: "최신 업데이트가 있습니다.\n업데이트 하시겠습니까?",
                en: "A new update is available. Would you like to update now?",
                ja: "最新のアップデートがあります。\nアップデートしますか？"
            )
        }

        static var updateConfirm: String {
            pick(ko: "업데이트", en: "Update", ja: "アップデート")
        }

        static var updateCancel: String {
            pick(ko: "다음에", en: "Later", ja: "あとで")
        }

        static var forcedUpdateDesc: String {
            pick(
                ko: "필수 업데이트가 있습니다.\n업데이트 후 사용가능합니다.",
                en: "A required update is available. Please update to continue.",
                ja: "必須アップデートがあります。\nアップデート後に利用できます。"
            )
        }
    }

    // 설정 화면 및 계정 관련 공통 문구는 아래 Settings 네임스페이스에 포함됨

    // 설정 > 공통 및 회원탈퇴(SignOut)
    enum Settings {
        static var title: String {
            pick(ko: "설정", en: "Settings", ja: "設定")
        }

        static var notificationSettings: String {
            pick(ko: "알림 설정", en: "Notification settings", ja: "通知設定")
        }

        static var languageSettings: String {
            pick(ko: "언어 설정", en: "Language settings", ja: "言語設定")
        }

        static var contentViewSettings: String {
            pick(ko: "콘텐츠 보기 설정", en: "Content view settings", ja: "コンテンツ表示設定")
        }

        static var termsOfService: String {
            pick(ko: "이용약관", en: "Terms of service", ja: "利用規約")
        }

        static var privacyPolicy: String {
            pick(ko: "개인정보처리방침", en: "Privacy policy", ja: "プライバシーポリシー")
        }

        static var appVersionInfo: String {
            pick(ko: "앱 버전 정보", en: "App version info", ja: "アプリバージョン情報")
        }

        static var logout: String {
            pick(ko: "로그아웃", en: "Log out", ja: "ログアウト")
        }

        static var logoutAllDevices: String {
            pick(ko: "모든 기기에서 로그아웃", en: "Log out from all devices", ja: "すべての端末でログアウト")
        }

        static var signOut: String {
            pick(ko: "회원탈퇴", en: "Delete account", ja: "退会")
        }

        static var companyInfo: String {
            pick(
                ko: """
- 회사명 : 주식회사 소다라이브

- 대표자 : 이재형

- 주소 : 경기도 성남시 분당구 황새울로335번길 10, 5층 563A호

- 사업자등록번호 : 870-81-03220

- 통신판매업신고 : 제2024-성남분당B-1012호

- 고객센터 : 02.2055.1477 (이용시간 10:00~19:00)

- 대표 이메일 : sodalive.official@gmail.com
""",
                en: """
- Company: SodaLive Co., Ltd.

- CEO: Jaehyung Lee

- Address: 5F 563A, 10, Hwangsaeul-ro335beon-gil, Bundang-gu, Seongnam-si, Gyeonggi-do

- Business Registration No.: 870-81-03220

- Mail-order business report No.: 2024-SeongnamBundangB-1012

- Customer center: +82-2-2055-1477 (Hours 10:00~19:00)

- Email: sodalive.official@gmail.com
""",
                ja: """
- 会社名：株式会社SodaLive

- 代表者：イ・ジェヒョン

- 住所：京畿道 城南市 盆唐区 黄새울路335番ギル10、5階563A号

- 事業者登録番号：870-81-03220

- 通信販売業届出：第2024-城南盆唐B-1012号

- カスタマーセンター：02.2055.1477（利用時間 10:00~19:00）

- 代表メール：sodalive.official@gmail.com
"""
            )
        }

        // 알림 다이얼로그 타이틀
        static var alertTitle: String { pick(ko: "알림", en: "Notice", ja: "お知らせ") }

        static var adultContentAgeCheckTitle: String {
            pick(
                ko: "당신은 18세 이상입니까?",
                en: "Are you over 18 years old?",
                ja: "あなたは18歳以上ですか？"
            )
        }

        static var adultContentAgeCheckDesc: String {
            pick(
                ko: "해당 콘텐츠는 18세 이상만 이용이 가능합니다!",
                en: "This content is available only to users aged 18 and over!",
                ja: "このコンテンツは18歳以上のみ利用可能です！"
            )
        }

        static var adultContentEnableGuide: String {
            pick(
                ko: "민감한 콘텐츠를 보려면 콘텐츠 보기 설정에서 민감한 콘텐츠 보기를 켜주세요.",
                en: "To view sensitive content, turn on Sensitive Content in Content View Settings.",
                ja: "センシティブなコンテンツを表示するには、コンテンツ表示設定でセンシティブなコンテンツ表示をオンにしてください。"
            )
        }

        // 로그아웃 확인 질문
        static var logoutQuestion: String {
            pick(
                ko: "로그아웃 하시겠어요?",
                en: "Do you want to log out?",
                ja: "ログアウトしますか？"
            )
        }

        // 모든 기기 로그아웃 확인 질문
        static var logoutAllQuestion: String {
            pick(
                ko: "모든 기기에서 로그아웃 하시겠어요?",
                en: "Do you want to log out from all devices?",
                ja: "すべてのデバイスからログアウトしますか？"
            )
        }

        enum Content {
            static var sensitiveContentTitle: String {
                pick(ko: "민감한 콘텐츠 보기", en: "Show sensitive content", ja: "センシティブなコンテンツ表示")
            }

            static var all: String {
                pick(ko: "전체", en: "All", ja: "全体")
            }

            static var maleOriented: String {
                pick(ko: "남성향", en: "Male-oriented", ja: "男性向け")
            }

            static var femaleOriented: String {
                pick(ko: "여성향", en: "Female-oriented", ja: "女性向け")
            }
        }

        enum Event {
            static var title: String {
                pick(ko: "이벤트", en: "Events", ja: "イベント")
            }

            static var detailTitle: String {
                pick(ko: "이벤트 상세", en: "Event details", ja: "イベント詳細")
            }

            static var participateButton: String {
                pick(ko: "이벤트 참여하기", en: "Participate in event", ja: "イベントに参加する")
            }
        }

        enum Language {
            static var systemDefault: String {
                pick(ko: "시스템 기본", en: "System default", ja: "システム設定")
            }

            static var korean: String {
                pick(ko: "한국어", en: "한국어", ja: "한국어")
            }

            static var english: String {
                pick(ko: "English", en: "English", ja: "English")
            }

            static var japanese: String {
                pick(ko: "日本語", en: "日本語", ja: "日本語")
            }

            static var apply: String {
                pick(ko: "적용", en: "Apply", ja: "適用")
            }
        }

        enum Notice {
            static var title: String {
                pick(ko: "공지사항", en: "Notices", ja: "お知らせ")
            }

            static var detailTitle: String {
                pick(ko: "공지사항 상세", en: "Notice details", ja: "お知らせ詳細")
            }
        }

        enum Notification {
            static var title: String {
                pick(ko: "알림 설정", en: "Notification settings", ja: "通知設定")
            }

            static var receiveSettingsTitle: String {
                pick(ko: "알림 수신 설정", en: "Notification receive settings", ja: "通知受信設定")
            }

            static var serviceNotifications: String {
                pick(ko: "서비스 알림", en: "Service notifications", ja: "サービス通知")
            }

            static var live: String {
                pick(ko: "라이브 알림", en: "Live notifications", ja: "ライブ通知")
            }

            static var contentUpload: String {
                pick(ko: "콘텐츠 업로드 알림", en: "Content upload notifications", ja: "コンテンツアップロード通知")
            }

            static var message: String {
                pick(ko: "메시지 알림", en: "Message notifications", ja: "メッセージ通知")
            }

            static var confirm: String {
                pick(ko: "확인", en: "Confirm", ja: "確認")
            }

            static var followingChannels: String {
                pick(ko: "팔로잉 채널", en: "Following channels", ja: "フォロー中のチャンネル")
            }

            static var totalPrefix: String {
                pick(ko: "총", en: "Total", ja: "合計")
            }

            static var countUnit: String {
                pick(ko: "명", en: "", ja: "名")
            }

            static var noFollowingChannels: String {
                pick(ko: "팔로우 중인 채널이 없습니다.", en: "There are no followed channels.", ja: "フォロー中のチャンネルがありません。")
            }
        }

        enum SignOut {
            static var title: String {
                pick(ko: "회원탈퇴", en: "Delete account", ja: "退会")
            }

            static var headline: String {
                pick(
                    ko: "정말로 탈퇴하실 거에요?\n한 번 더 생각해보지 않으실래요?",
                    en: "Are you sure you want to leave?\nWould you like to think one more time?",
                    ja: "本当に退会しますか？\nもう一度ご検討いただけませんか？"
                )
            }

            static var reasonGuide: String {
                pick(
                    ko: "계정을 삭제하려는 이유를 선택해주세요.\n서비스 개선에 중요한 자료로 활용하겠습니다.",
                    en: "Please select the reason for deleting your account.\nThis will be used as important feedback to improve our service.",
                    ja: "アカウント削除の理由を選択してください。\nサービス改善のための重要な資料として活用します。"
                )
            }

            static var reasonInputPlaceholder: String {
                pick(ko: "입력해주세요", en: "Please enter", ja: "入力してください")
            }

            static var accountDeletionNotice: String {
                pick(
                    ko: "계정을 삭제하면 회원님의 모든 콘텐츠와 활동 길고, 캔충전 및 적립, 사용내역 등의 기록이 삭제됩니다. 삭제된 정보는 복구할 수 없으니 신중히 결정해주세요.\n캔 충전하기를 통해 적립한 캔은 계정 삭제시 환불이 불가합니다. 또한 환불 신청 후 환불처리가 되기 전에 계정을 삭제하는 경우 포인트 사용내역을 확인할 수 없어 환불이 불가합니다.",
                    en: "If you delete your account, all your content and activity records, including can charge/savings and usage history, will be deleted. Deleted information cannot be recovered, so please decide carefully.\nCans earned through can charging are not refundable when deleting your account. Also, if you delete your account before a requested refund is processed, a refund is not possible because point usage history cannot be confirmed.",
                    ja: "アカウントを削除すると、すべてのコンテンツと活動履歴、canチャージおよび積立、利用履歴などが削除されます。削除された情報は復元できないため、慎重にご判断ください。\ncanチャージで積み立てたcanはアカウント削除時に返金できません。また、返金申請後に返金処理前にアカウントを削除した場合、ポイント利用履歴を確認できないため返金できません。"
                )
            }

            static var socialLoginGuide: String {
                pick(
                    ko: "※ 소셜 로그인 이용자는 비밀번호를 입력하지 말고 '탈퇴하기'를 클릭하면 자동 탈퇴됩니다.",
                    en: "※ If you use social login, do not enter a password and click 'Delete account' to complete withdrawal automatically.",
                    ja: "※ ソーシャルログイン利用者はパスワードを入力せず、「退会する」を押すと自動で退会されます。"
                )
            }

            static var submit: String {
                pick(ko: "탈퇴하기", en: "Delete account", ja: "退会する")
            }

            // 탈퇴 사유 목록 (UI에서 그대로 배열로 사용 가능)
            static var reasons: [String] {
                [
                    reasonChangeNickname,
                    reasonConflictWithUser,
                    reasonInconvenientManyErrors,
                    reasonDislikeOperation,
                    reasonOtherServiceBetter,
                    reasonWantToDeleteContent,
                    reasonLowFrequency,
                    reasonNoDesiredContentOrCreator,
                    reasonTooExpensive,
                    other
                ]
            }

            static var reasonChangeNickname: String {
                pick(
                    ko: "닉네임을 변경하고 싶어서",
                    en: "I want to change my nickname",
                    ja: "ハンドルネームを変えたいから"
                )
            }

            static var reasonConflictWithUser: String {
                pick(
                    ko: "다른 사용자와의 다툼이 있어서",
                    en: "Conflict with another user",
                    ja: "他ユーザーとのトラブルがあったから"
                )
            }

            static var reasonInconvenientManyErrors: String {
                pick(
                    ko: "이용이 불편하고 장애가 많아서",
                    en: "Inconvenient to use and many errors",
                    ja: "使いにくく不具合が多いから"
                )
            }

            static var reasonDislikeOperation: String {
                pick(
                    ko: "서비스 운영이 마음에 들지 않아서",
                    en: "Dissatisfied with service operations",
                    ja: "運営が気に入らないから"
                )
            }

            static var reasonOtherServiceBetter: String {
                pick(
                    ko: "다른 서비스가 더 좋아서",
                    en: "Another service is better",
                    ja: "他サービスの方が良いから"
                )
            }

            static var reasonWantToDeleteContent: String {
                pick(
                    ko: "삭제하고 싶은 내용이 있어서",
                    en: "I want to delete some content",
                    ja: "削除したい内容があるから"
                )
            }

            static var reasonLowFrequency: String {
                pick(
                    ko: "이용빈도가 낮아서",
                    en: "I use the service infrequently",
                    ja: "利用頻度が低いから"
                )
            }

            static var reasonNoDesiredContentOrCreator: String {
                pick(
                    ko: "원하는 콘텐츠나 크리에이터가 없어서",
                    en: "I can't find desired content or creators",
                    ja: "好きなコンテンツやクリエイターがいないから"
                )
            }

            static var reasonTooExpensive: String {
                pick(
                    ko: "이용요금이 비싸서",
                    en: "The price is too high",
                    ja: "利用料金が高いから"
                )
            }

            static var other: String {
                pick(
                    ko: "기타",
                    en: "Other",
                    ja: "その他"
                )
            }

            // 검증 메시지
            static var selectReasonRequired: String {
                pick(
                    ko: "계정을 삭제하려는 이유를 선택해 주세요.", en: "select a reason for deleting your account.",
                    ja: "アカウント削除理由を選択してください。"
                )
            }

            // 비밀번호 확인 필드
            static var passwordTitle: String {
                pick(
                    ko: "비밀번호 확인",
                    en: "Password confirmation",
                    ja: "パスワード確認"
                )
            }

            static var passwordPlaceholder: String {
                pick(
                    ko: "비밀번호를 입력해주세요.",
                    en: "Please enter your password.",
                    ja: "パスワードを入力してください。"
                )
            }
        }
    }

    enum Charge {
        static var inAppPurchase: String {
            pick(ko: "인 앱 결제", en: "In-app purchase", ja: "アプリ内課金")
        }
    }

    // 쿠폰 등록/사용 화면 관련 텍스트
    enum CanCoupon {
        // 화면 타이틀
        static var title: String {
            pick(ko: "쿠폰등록", en: "Register coupon", ja: "クーポン登録")
        }

        // 입력 섹션
        static var inputTitle: String {
            pick(ko: "쿠폰번호 입력", en: "Enter coupon code", ja: "クーポン番号入力")
        }

        static var inputPlaceholder: String {
            pick(
                ko: "쿠폰번호를 입력하세요",
                en: "Enter coupon code",
                ja: "クーポン番号を入力してください"
            )
        }

        // 액션 버튼
        static var submit: String {
            pick(ko: "등록하기", en: "Register", ja: "登録する")
        }

        // 섹션 헤더
        static var guideHeader: String {
            pick(ko: "[등록 및 사용안내]", en: "[Registration and usage]", ja: "[登録および使用案内]")
        }

        static var cautionHeader: String {
            pick(ko: "[주의사항]", en: "[Notes]", ja: "[注意事項]")
        }

        // 안내 항목
        static var guide1: String {
            pick(
                ko: "공백없이 쿠폰번호 12자리를 입력해주세요.",
                en: "Enter 12 characters without spaces.",
                ja: "スペースなしで12桁のクーポン番号を入力してください。"
            )
        }

        static var guide2: String {
            pick(
                ko: "충전된 캔 또는 포인트는 해당 충전현황에서 확인할 수 있습니다",
                en: "You can check charged cans or points in the charge status.",
                ja: "チャージされたcanまたはポイントはチャージ状況で確認できます。"
            )
        }

        static var guide3: String {
            pick(
                ko: "쿠폰으로 충전된 캔은 사용 전까지 소멸되지 않으며, 포인트는 충전 후 72시간 이내에 사용하지 않으면 자동 소멸됩니다.",
                en: "Cans charged by coupon do not expire before use. Points expire automatically if not used within 72 hours after charging.",
                ja: "クーポンでチャージしたcanは使用前に失効しません。ポイントはチャージ後72時間以内に使用しないと自動的に失効します。"
            )
        }

        // 주의사항 항목
        static var caution1: String {
            pick(
                ko: "이벤트 쿠폰을 통해 충전한 캔이나 포인트는 환불되지 않습니다.",
                en: "Cans or points charged via event coupons are non-refundable.",
                ja: "イベントクーポンでチャージしたcanやポイントは返金できません。"
            )
        }

        static var caution2: String {
            pick(
                ko: "쿠폰은 상업적 용도로 사용하거나 매매할 수 없습니다.",
                en: "Coupons may not be used for commercial purposes or traded.",
                ja: "クーポンを商用目的で使用したり売買したりすることはできません。"
            )
        }

        static var caution3: String {
            pick(
                ko: "한번 등록한 쿠폰은 재사용이 불가합니다.",
                en: "A coupon can’t be used again once registered.",
                ja: "一度登録したクーポンは再使用できません。"
            )
        }

        static var caution4: String {
            pick(
                ko: "연령 제한 정책에 따라 쿠폰이용은 본인인증한 회원만 이용 가능합니다.",
                en: "Due to age policy, only verified members can use coupons.",
                ja: "年齢制限ポリシーにより、本人確認済みの会員のみクーポンを利用できます。"
            )
        }

        static var contactHelp: String {
            pick(
                ko: "※ 쿠폰 등록 및 이용에 문제가 발생한 경우 '고객센터'로 문의주시기 바랍니다.",
                en: "※ If you have issues with coupon registration or use, please contact Customer Service.",
                ja: "※ クーポンの登録・利用に問題が発生した場合は『カスタマーセンター』までお問い合わせください。"
            )
        }

        // 성공/토스트
        static var useCompleted: String {
            pick(
                ko: "쿠폰 사용이 완료되었습니다.",
                en: "Coupon use completed.",
                ja: "クーポンの使用が完了しました。"
            )
        }
    }

    enum MissionMenu {
        static var menu1: String { pick(ko: "메뉴 1", en: "Menu 1", ja: "メニュー 1") }
        static var menu2: String { pick(ko: "메뉴 2", en: "Menu 2", ja: "メニュー 2") }
        static var menu3: String { pick(ko: "메뉴 3", en: "Menu 3", ja: "メニュー 3") }

        static var needMenu1First: String { pick(ko: "메뉴 1을 먼저 설정하세요", en: "Please set Menu 1 first", ja: "まずメニュー1を設定してください") }
        static var needMenu1And2First: String { pick(ko: "메뉴 1과 메뉴 2를 먼저 설정하세요", en: "Please set Menu 1 and Menu 2 first", ja: "メニュー1と2を先に設定してください") }
    }

    enum CreateLive {
        // 라이브 공지 입력 힌트
        static var noticePlaceholder: String {
            pick(ko: "라이브 공지를 입력하세요", en: "Enter live notice", ja: "ライブのお知らせを入力してください")
        }

        // 시간 설정
        static var startNow: String { pick(ko: "지금 즉시", en: "Now", ja: "今すぐ") }
        static var schedule: String { pick(ko: "예약 설정", en: "Booking", ja: "予約設定") }

        // 공개 범위
        static var publicRoom: String { pick(ko: "공개", en: "Open", ja: "公開") }
        static var privateRoom: String { pick(ko: "비공개", en: "Private", ja: "非公開") }

        // 참여 가능 여부
        static var joinAllowed: String { pick(ko: "가능", en: "Allowed", ja: "可能") }
        static var joinNotAllowed: String { pick(ko: "불가능", en: "Not allowed", ja: "不可") }

        static var captureRecordingSetting: String { pick(ko: "캡쳐/녹화 허용", en: "Capture/recording", ja: "キャプチャ/録画") }
        static var captureRecordingAllowed: String { pick(ko: "가능", en: "Allowed", ja: "可能") }
        static var captureRecordingNotAllowed: String { pick(ko: "불가능", en: "Not allowed", ja: "不可") }

        // 연령 제한
        static var allAges: String { pick(ko: "전체 연령", en: "All ages", ja: "全年齢") }
        static var over19: String { pick(ko: "19세 이상", en: "19+", ja: "R-18") }

        // 성별 제한
        static var genderRestrictionTitle: String { pick(ko: "성별 제한", en: "Gender restriction", ja: "性別制限") }
        static var genderAll: String { pick(ko: "전체", en: "All", ja: "全体") }
        static var genderMaleOnly: String { pick(ko: "남자만", en: "Male only", ja: "男性のみ") }
        static var genderFemaleOnly: String { pick(ko: "여자만", en: "Female only", ja: "女性のみ") }

        // 최근 데이터 관련 토스트/알림
        static var recentDataLoaded: String { pick(ko: "최근데이터를 불러왔습니다.", en: "Recent data has been loaded.", ja: "最新データを読み込みました。") }
        static var recentDataLoadFailed: String { pick(ko: "최근데이터를 불러오지 못했습니다.\n다시 시도해 주세요.", en: "Failed to load recent data.\ntry again.", ja: "最近のデータを読み込めませんでした。\n恐れ入りますが、もう一度お試しください。") }
        static var createLiveFailedGeneric: String { pick(ko: "라이브를 만들지 못했습니다.\n다시 시도해 주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.", en: "Could not create the live.\nPlease try again.\nIf the problem persists, please contact customer support.", ja: "ライブを作成できませんでした。\nもう一度お試しください。\n問題が続く場合はカスタマーサポートにお問い合わせください。") }

        // 검증 에러 메시지
        static var selectCoverImage: String { pick(ko: "커버이미지를 선택해주세요.", en: "Please select a cover image.", ja: "カバー画像を選択してください。") }
        static var enterTitle: String { pick(ko: "제목을 입력해 주세요.", en: "Please enter a title.", ja: "タイトルを入力してください。") }
        static var enterNoticeMin5: String { pick(ko: "공지를 5자 이상 입력해주세요.", en: "Please enter at least 5 characters for the notice.", ja: "お知らせは5文字以上で入力してください。") }
        static var enterPeopleRange: String { pick(ko: "인원을 3~999명 사이로 입력해주세요.", en: "Please enter the number of people between 3 and 999.", ja: "人数を3~999名の間で入力してください。") }
        static var enterPaidPriceMin30: String { pick(ko: "유료 라이브는 30캔 이상 설정해주세요.", en: "For paid live, set at least 30 cans.", ja: "有料ライブは30can以上で設定してください。") }
        static var enterPassword6: String { pick(ko: "방 입장 비밀번호 6자리를 입력해 주세요.", en: "Please enter a 6-digit room entry password.", ja: "入室パスワード（6桁）を入力してください。") }

        static var createLiveTitle: String { pick(ko: "라이브 만들기", en: "Create live", ja: "ライブを作成") }
        static var fetchRecentData: String { pick(ko: "최근 데이터 가져오기", en: "Load recent data", ja: "最近のデータを読み込む") }
        static var thumbnail: String { pick(ko: "썸네일", en: "Thumbnail", ja: "サムネイル") }
        static var creatorEntrySetting: String { pick(ko: "크리에이터 입장 설정", en: "Creator entry setting", ja: "クリエイター入場設定") }
        static var openLiveAction: String { pick(ko: "라이브 오픈하기", en: "Open live", ja: "ライブを開始") }

        static var titleLabel: String { pick(ko: "제목", en: "Title", ja: "タイトル") }
        static var titlePlaceholder: String { pick(ko: "라이브 제목을 입력하세요", en: "Enter live title", ja: "ライブタイトルを入力してください") }
        static var interestsLabel: String { pick(ko: "관심사", en: "Interests", ja: "関心事") }
        static var selectInterestsAction: String { pick(ko: "관심사 선택", en: "Select interests", ja: "関心事を選択") }
        static var noticeLabel: String { pick(ko: "공지", en: "Notice", ja: "お知らせ") }
        static func noticeCount(_ count: Int) -> String {
            pick(ko: "\(count)자", en: "\(count) chars", ja: "\(count)字")
        }
        static var noticeLimitSuffix: String { pick(ko: " / 1000자", en: " / 1000 chars", ja: " / 1000字") }

        static var timeSettingLabel: String { pick(ko: "시간설정", en: "Time setting", ja: "時間設定") }
        static var reservationDateLabel: String { pick(ko: "예약 날짜", en: "Reservation date", ja: "予約日") }
        static var reservationTimeLabel: String { pick(ko: "예약 시간", en: "Reservation time", ja: "予約時間") }
        static var participantLimitLabel: String { pick(ko: "참여인원 설정", en: "Participant limit", ja: "参加人数設定") }
        static var participantLimitPlaceholder: String { pick(ko: "최대 인원 999명", en: "Max 999 participants", ja: "最大999人") }
        static var confirmButton: String { pick(ko: "확인", en: "Confirm", ja: "確認") }

        static var visibilityLabel: String { pick(ko: "공개 설정", en: "Visibility", ja: "公開設定") }
        static var roomPasswordTitle: String { pick(ko: "방 비밀번호 입력", en: "Enter room password", ja: "入室パスワード入力") }
        static var roomPasswordPlaceholder: String { pick(ko: "방 입장 비밀번호 6자리를 입력해 주세요.", en: "Enter 6-digit room password", ja: "入室パスワード6桁を入力してください") }
        static var ageRestrictionLabel: String { pick(ko: "연령 제한", en: "Age restriction", ja: "年齢制限") }
        static var ticketPriceLabel: String { pick(ko: "티켓 가격", en: "Ticket price", ja: "チケット価格") }
        static var canUnit: String { pick(ko: "캔", en: "cans", ja: "can") }
        static func priceOption(_ price: Int) -> String {
            pick(
                ko: price == 0 ? "무료" : "\(price) 캔",
                en: price == 0 ? "Free" : "\(price) cans",
                ja: price == 0 ? "無料" : "\(price)can"
            )
        }

        static var tagSelectionTitle: String { pick(ko: "관심사 선택", en: "Select interests", ja: "関心事を選択") }
        static var tagSelectionSubtitle: String { pick(ko: "최대 3개까지 선택 가능합니다.", en: "You can select up to 3.", ja: "最大3つまで選択できます。") }
        static var tagConfirmButton: String { pick(ko: "확인", en: "Confirm", ja: "確認") }

        static var menuTitle: String { pick(ko: "메뉴", en: "Menu", ja: "メニュー") }
        static var menuActivatePrompt: String { pick(ko: "메뉴를 활성화 하시겠습니까?", en: "Activate menu?", ja: "メニューを有効化しますか？") }
        static var menuPlaceholder: String { pick(ko: "메뉴판을 작성해주세요.", en: "Please write the menu board.", ja: "メニュー表を入力してください。") }
        static var saveMenuAction: String { pick(ko: "저장하기", en: "Save", ja: "保存する") }
        static var menuSavedMessage: String { pick(ko: "저장되었습니다.", en: "Saved.", ja: "保存されました。") }

        static var editLiveTitle: String { pick(ko: "라이브 수정", en: "Edit live", ja: "ライブ編集") }
        static var editAction: String { pick(ko: "수정하기", en: "Edit", ja: "編集する") }
        static var entryMessageLabel: String { pick(ko: "입장메시지", en: "Entry message", ja: "入場メッセージ") }
        static var noChangesMessage: String { pick(ko: "변경사항이 없습니다.", en: "No changes.", ja: "変更事項がありません。") }
        static var editSuccessMessage: String { pick(ko: "라이브 정보가 수정되었습니다.", en: "Live info has been updated.", ja: "ライブ情報を更新しました。") }
        static var editFailedMessage: String {
            pick(
                ko: "라이브 정보를 수정하지 못했습니다.\n다시 시도해 주세요.",
                en: "Failed to update live info.\nPlease try again.",
                ja: "ライブ情報を更新できませんでした。\nもう一度お試しください。"
            )
        }

        static var donationHistoryTitle: String { pick(ko: "후원 히스토리", en: "Donation history", ja: "後援履歴") }
        static var donationHistoryCopied: String { pick(ko: "후원 히스토리가 복사되었습니다.", en: "Donation history copied.", ja: "後援履歴をコピーしました。") }
        static var donationHistoryEmpty: String { pick(ko: "후원 히스토리가 없습니다.", en: "No donation history.", ja: "後援履歴がありません。") }
        static var closeAction: String { pick(ko: "닫기", en: "Close", ja: "閉じる") }

        static var donationRankingTitle: String { pick(ko: "현재 라이브 후원랭킹", en: "Current live donation ranking", ja: "現在のライブ後援ランキング") }
        static var heartRankingTitle: String { pick(ko: "현재 라이브 하트랭킹", en: "Current live heart ranking", ja: "現在のライブハートランキング") }
        static var totalLabel: String { pick(ko: "전체", en: "Total", ja: "全体") }
        static var peopleUnit: String { pick(ko: "명", en: "people", ja: "人") }
        static var sumLabel: String { pick(ko: "합계", en: "Sum", ja: "合計") }
        static var normalLabel: String { pick(ko: "일반", en: "Normal", ja: "一般") }
        static var secretLabel: String { pick(ko: "비밀", en: "Secret", ja: "秘密") }
        static var heartLabel: String { pick(ko: "하트", en: "Heart", ja: "ハート") }

        static var noChattingTitle: String { pick(ko: "채팅금지", en: "Chat ban", ja: "チャット禁止") }
        static var noChattingQuestion: String { pick(ko: "3분간 채팅금지를 하겠습니까?", en: "Ban chat for 3 minutes?", ja: "3分間チャットを禁止しますか？") }
        static var profileTitle: String { pick(ko: "프로필", en: "Profile", ja: "プロフィール") }
        static var inviteSpeakerAction: String { pick(ko: "스피커로 초대", en: "Invite as speaker", ja: "スピーカーに招待") }
        static var changeListenerAction: String { pick(ko: "리스너 변경", en: "Switch to listener", ja: "リスナーへ変更") }
        static var staffReleaseAction: String { pick(ko: "스탭 해제", en: "Release staff", ja: "スタッフ解除") }
        static var staffAssignAction: String { pick(ko: "스탭 지정", en: "Assign staff", ja: "スタッフ指定") }
        static var kickOutAction: String { pick(ko: "내보내기", en: "Kick out", ja: "退場") }
        static var noChattingAction: String { pick(ko: "3분간 채팅금지", en: "3-min chat ban", ja: "3分間チャット禁止") }
        static var shortNoChattingAction: String { pick(ko: "채금", en: "Mute", ja: "チャ禁") }
        static var requestSpeakerAction: String { pick(ko: "스피커 요청하기", en: "Request speaker", ja: "スピーカー要請") }
        static var participantTitle: String { pick(ko: "참여자", en: "Participants", ja: "参加者") }
        static var staffTitle: String { pick(ko: "스탭", en: "Staff", ja: "スタッフ") }
        static var speakerTitle: String { pick(ko: "스피커", en: "Speaker", ja: "スピーカー") }
        static var listenerTitle: String { pick(ko: "리스너", en: "Listener", ja: "リスナー") }

        static var rouletteSettingsTitle: String { pick(ko: "룰렛 설정", en: "Roulette settings", ja: "ルーレット設定") }
        static var rouletteActivatePrompt: String { pick(ko: "룰렛을 활성화 하시겠습니까?", en: "Activate roulette?", ja: "ルーレットを有効化しますか？") }
        static var rouletteCanSettingTitle: String { pick(ko: "룰렛 금액 설정", en: "Roulette amount", ja: "ルーレット金額設定") }
        static var rouletteCanPlaceholder: String { pick(ko: "룰렛 금액을 입력해 주세요 (최소 5캔)", en: "Enter roulette amount (min 5 cans)", ja: "ルーレット金額を入力してください（最小5can）") }
        static var rouletteOptionSettingTitle: String { pick(ko: "룰렛 옵션 설정", en: "Roulette options", ja: "ルーレットオプション設定") }
        static var rouletteOptionLimitNotice: String { pick(ko: "※ 룰렛 옵션은 최소 2개,\n최대 10개까지 설정할 수 있습니다.", en: "※ You can set 2 to 10 options.", ja: "※ ルーレットオプションは2個以上10個以下で設定できます。") }
        static var rouletteProbabilitySum: String { pick(ko: "옵션 확률 합계", en: "Total option probability", ja: "オプション確率合計") }
        static var roulettePreviewAction: String { pick(ko: "미리보기", en: "Preview", ja: "プレビュー") }
        static var rouletteCompleteAction: String { pick(ko: "설정완료", en: "Complete", ja: "設定完了") }
        static var roulettePreviewTitle: String { pick(ko: "룰렛 미리보기", en: "Roulette preview", ja: "ルーレットプレビュー") }
        static func rouletteSpinWithCan(_ can: Int) -> String {
            pick(ko: "\(can)캔으로 룰렛 돌리기", en: "Spin roulette with \(can) cans", ja: "\(can)canでルーレットを回す")
        }
        static func rouletteOptionTitle(_ index: Int) -> String { pick(ko: "옵션 \(index + 1)", en: "Option \(index + 1)", ja: "オプション \(index + 1)") }
        static var rouletteDeleteAction: String { pick(ko: "삭제", en: "Delete", ja: "削除") }
        static var rouletteOptionPlaceholder: String { pick(ko: "옵션을 입력하세요", en: "Enter option", ja: "オプションを入力してください") }
        static var rouletteOptionEmptyError: String { pick(ko: "옵션은 빈칸일 수 없습니다.", en: "Options cannot be empty.", ja: "オプションは空欄にできません。") }
        static var rouletteProbabilityInvalidError: String { pick(ko: "확률이 100%가 아닙니다", en: "Probability is not 100%.", ja: "確率が100%ではありません。") }
        static var rouletteNoChangesMessage: String { pick(ko: "변동사항이 없습니다.", en: "No changes.", ja: "変更事項がありません。") }
        static var rouletteNeedFirstMessage: String { pick(ko: "룰렛 1을 먼저 설정하세요", en: "Set Roulette 1 first.", ja: "先にルーレット1を設定してください。") }
        static var rouletteNeedFirstAndSecondMessage: String { pick(ko: "룰렛 1과 룰렛 2를 먼저 설정하세요", en: "Set Roulette 1 and 2 first.", ja: "先にルーレット1と2を設定してください。") }
        static func rouletteSetAsSuccess(_ title: String) -> String { pick(ko: "\(title)로 설정하였습니다.", en: "Set as \(title).", ja: "\(title)に設定しました。") }
        static func rouletteSetSuccess(_ title: String) -> String { pick(ko: "\(title)을 설정했습니다.", en: "\(title) has been set.", ja: "\(title)を設定しました。") }
        static func rouletteCreatedSuccess(_ title: String) -> String { pick(ko: "\(title)을 생성했습니다.", en: "\(title) has been created.", ja: "\(title)を作成しました。") }
        static func rouletteActivatedSuccess(_ title: String) -> String { pick(ko: "\(title)을 활성화 했습니다.", en: "\(title) has been activated.", ja: "\(title)を有効化しました。") }
        static func rouletteDeactivatedSuccess(_ title: String) -> String { pick(ko: "\(title)을 비활성화 했습니다.", en: "\(title) has been deactivated.", ja: "\(title)を無効化しました。") }
        static func rouletteChangedSuccess(_ title: String) -> String { pick(ko: "\(title)을 변경했습니다.", en: "\(title) has been changed.", ja: "\(title)を変更しました。") }
        static var rouletteUnavailableError: String { pick(ko: "룰렛을 사용할 수 없습니다. 다시 시도해 주세요.", en: "Roulette is unavailable. Please try again.", ja: "ルーレットを利用できません。もう一度お試しください。") }

        static var newChatLabel: String { pick(ko: "새로운 채팅", en: "New chat", ja: "新しいチャット") }
        static var communitySectionTitle: String { pick(ko: "커뮤니티", en: "Community", ja: "コミュニティ") }
        static var latestFinishedSectionTitle: String { pick(ko: "최근 종료한 라이브", en: "Recently ended live", ja: "最近終了したライブ") }
        static var noticeTag: String { pick(ko: "[방송공지]", en: "[Notice]", ja: "[お知らせ]") }
        static var menuTag: String { pick(ko: "[메뉴판]", en: "[Menu]", ja: "[メニュー表]") }

        static var detailViewChannel: String { pick(ko: "채널보기", en: "View channel", ja: "チャンネルを見る") }
        static var detailEdit: String { pick(ko: "수정", en: "Edit", ja: "編集") }
        static var detailStartLive: String { pick(ko: "라이브 시작", en: "Start live", ja: "ライブ開始") }
        static var detailReservationDelete: String { pick(ko: "예약삭제", en: "Delete reservation", ja: "予約削除") }
        static var detailReservationDone: String { pick(ko: "예약완료", en: "Reserved", ja: "予約完了") }
        static var detailReservationAction: String { pick(ko: "예약하기", en: "Reserve", ja: "予約する") }
        static var detailJoinNow: String { pick(ko: "지금 참여하기", en: "Join now", ja: "今すぐ参加") }
        static var detailReservationParticipant: String { pick(ko: "예약자", en: "Reserved users", ja: "予約者") }
        static var detailParticipant: String { pick(ko: "참가자", en: "Participants", ja: "参加者") }
        static var detailCollapse: String { pick(ko: "닫기", en: "Close", ja: "閉じる") }
        static var detailExpand: String { pick(ko: "펼쳐보기", en: "Expand", ja: "もっと見る") }

        static var speakerRequestSent: String { pick(ko: "스피커 요청을 보냈습니다.\n잠시만 기다려 주세요.", en: "Speaker request sent.\nPlease wait a moment.", ja: "スピーカー要請を送信しました。\nしばらくお待ちください。") }
        static var speakerCapacityExceeded: String { pick(ko: "스피커 정원을 초과했습니다.", en: "Speaker capacity exceeded.", ja: "スピーカー定員を超えました。") }
        static func remainingNoChattingMessage(_ seconds: Int) -> String { pick(ko: "\(seconds)초 동안 채팅하실 수 없습니다", en: "You cannot chat for \(seconds) seconds.", ja: "\(seconds)秒間チャットできません。") }
    }

    enum LiveRoom {
        static var ageRestrictionDesc: String {
            pick(
                ko: "지금 참여하던 라이브는 '19세 이상' 연령제한이 설정되어 정보통신망 이용촉진 및 정보 보호 등에 관한 법률 및 청소년 보호법의 규정에 의해 만 19세 미만의 청소년은 이용할 수 없습니다.\n마이페이지에서 본인인증 후 다시 이용하시기 바랍니다.",
                en: "The live you were joining has been set to '19+' and, under applicable laws, minors under 19 cannot use it.\nPlease verify your identity in My Page and try again.",
                ja: "参加中のライブは「19歳以上」に設定されており、関連法令により19歳未満の方はご利用いただけません。\nマイページで本人認証後、再度お試しください。"
            )
        }

        static var secretMissionLabel: String {
            pick(ko: "비밀미션", en: "Secret mission", ja: "秘密ミッション")
        }

        static var secretMissionMinimumCanMessage: String {
            pick(
                ko: "비밀 미션은 최소 10캔 이상부터 이용이 가능합니다.",
                en: "Secret mission is available from at least 10 cans.",
                ja: "秘密ミッションは最低10canから利用できます。"
            )
        }

        static var likeHeartNoticeDesc: String {
            pick(
                ko: "'좋아해요'는 유료 후원입니다.\n클릭시 1캔이 소진됩니다.",
                en: "'Like' is a paid donation.\nClicking consumes 1 can.",
                ja: "「좋아요」は有料の支援です。\nクリックすると1can消費されます。"
            )
        }

        static var quitTitle: String { pick(ko: "라이브 나가기", en: "Leave live", ja: "ライブを退出") }
        static var quitDesc: String { pick(ko: "라이브에서 나가시겠습니까?", en: "Do you want to leave the live?", ja: "ライブから退出しますか？") }
        static var leaveLiveForNavigationDesc: String {
            pick(
                ko: "다른 페이지로 이동시 현재 라이브에서 나가게 됩니다.",
                en: "Moving to another page will leave the current live.",
                ja: "別のページに移動すると、現在のライブから退出します。"
            )
        }

        static var endTitle: String { pick(ko: "라이브 종료", en: "End live", ja: "ライブ終了") }
        static var endDesc: String {
            pick(
                ko: "라이브를 종료하시겠습니까?\n라이브를 종료하면 대화내용은\n저장되지 않고 사라집니다.\n참여자들 또한 라이브가 종료되어\n강제퇴장 됩니다.",
                en: "Do you want to end the live?\nEnding the live will erase the chat history.\nParticipants will also be removed.",
                ja: "ライブを終了しますか？\n終了するとチャット内容は保存されず消えます。\nリスナーもライブ終了とともに\n強制退出されます。"
            )
        }

        static var kickOutTitle: String { pick(ko: "내보내기", en: "Kick out", ja: "退場させる") }
        static var kickOutConfirm: String { pick(ko: "내보내기", en: "Kick out", ja: "退場させる") }
        static func kickOutQuestion(_ nickname: String) -> String {
            pick(ko: "\(nickname)님을 내보내시겠어요?", en: "Kick out \(nickname)?", ja: "\(nickname)さんを退出させますか？")
        }
        static func kickedOutMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님을 내보냈습니다.", en: "\(nickname) has been removed.", ja: "\(nickname)さんを退出させました。")
        }
        static func staffReleasedMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님을 스탭에서 해제했어요.", en: "\(nickname) has been removed from staff.", ja: "\(nickname)さんのスタッフ権限を解除しました。")
        }
        static func changedToListenerMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님을 리스너로 변경했어요.", en: "\(nickname) was changed to listener.", ja: "\(nickname)さんをリスナーに変更しました。")
        }
        static func assignedStaffMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님을 스탭으로 지정했습니다.", en: "\(nickname) was assigned as staff.", ja: "\(nickname)さんをスタッフに指定しました。")
        }
        static func noChattingAppliedMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님을 3분간 채팅금지를 하였습니다.", en: "\(nickname) has been chat-banned for 3 minutes.", ja: "\(nickname)さんを3分間チャット禁止にしました。")
        }
        static func noChattingByCreatorMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님이 3분간 채팅을 금지하였습니다.", en: "\(nickname) has muted your chat for 3 minutes.", ja: "\(nickname)さんが3分間チャットを禁止しました。")
        }
        static var noChattingReleasedMessage: String { pick(ko: "채팅금지가 해제되었습니다.", en: "Chat ban has been lifted.", ja: "チャット禁止が解除されました。") }

        static var becameSpeakerMessage: String { pick(ko: "스피커가 되었어요!", en: "You are now a speaker!", ja: "スピーカーになりました！") }
        static var atLeastOneCanDonationMessage: String { pick(ko: "1캔 이상 후원하실 수 있습니다.", en: "You can donate 1 can or more.", ja: "1can以上後援できます。") }
        static var donationFailedMessage: String {
            pick(
                ko: "후원에 실패했습니다.\n다시 후원해주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                en: "Donation failed.\nPlease try donating again.\nIf the problem persists, contact customer support.",
                ja: "後援に失敗しました。\nもう一度後援してください。\n問題が続く場合はカスタマーサポートへお問い合わせください。"
            )
        }
        static var donationRefundFailedMessage: String {
            pick(
                ko: "후원에 실패한 캔이 환불되지 않았습니다\n고객센터로 문의해주세요.",
                en: "Failed donation cans were not refunded.\nPlease contact customer support.",
                ja: "後援失敗分のcanが返金されませんでした。\nカスタマーサポートへお問い合わせください。"
            )
        }
        static var donationStatusFetchFailed: String {
            pick(ko: "후원현황을 가져오지 못했습니다\n다시 시도해 주세요.", en: "Failed to load donation status.\nPlease try again.", ja: "後援状況を取得できませんでした。\nもう一度お試しください。")
        }
        static var heartRankingFetchFailed: String {
            pick(ko: "하트 랭킹을 가져오지 못했습니다\n다시 시도해 주세요.", en: "Failed to load heart ranking.\nPlease try again.", ja: "ハートランキングを取得できませんでした。\nもう一度お試しください。")
        }

        static var liveEndedMessage: String { pick(ko: "라이브가 종료되었습니다.", en: "The live has ended.", ja: "ライブが終了しました。") }
        static func speakerRequestQuestion(_ nickname: String) -> String {
            pick(ko: "\(nickname)님이 스피커 요청을 했어요!\n스피커로 초대할까요?", en: "\(nickname) requested to be a speaker.\nInvite as speaker?", ja: "\(nickname)さんがスピーカーを要請しました。\nスピーカーに招待しますか？")
        }
        static var skipAction: String { pick(ko: "건너뛰기", en: "Skip", ja: "スキップ") }
        static var maybeLaterAction: String { pick(ko: "다음에요", en: "Maybe later", ja: "あとで") }
        static var joinAsSpeakerAction: String { pick(ko: "스피커로 참여하기", en: "Join as speaker", ja: "スピーカーとして参加") }
        static func kickedOutByCreatorMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님이 라이브에서 내보냈습니다.", en: "\(nickname) removed you from the live.", ja: "\(nickname)さんがライブから退出させました。")
        }
        static var kickedOutByHostMessage: String { pick(ko: "방장님이 라이브에서 내보냈습니다.", en: "Host removed you from the live.", ja: "配信者がライブから退出させました。") }
        static func assignedStaffByCreatorMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님이 스탭으로 지정했습니다.", en: "\(nickname) assigned you as staff.", ja: "\(nickname)さんがあなたをスタッフに指定しました。")
        }
        static var assignedStaffByHostMessage: String { pick(ko: "방장님이 스탭으로 지정했습니다", en: "Host assigned you as staff.", ja: "配信者があなたをスタッフに指定しました。") }
        static func releasedStaffByCreatorMessage(_ nickname: String) -> String {
            pick(ko: "\(nickname)님이 스탭에서 해제했습니다.", en: "\(nickname) removed your staff role.", ja: "\(nickname)さんがあなたのスタッフ権限を解除しました。")
        }
        static var releasedStaffByHostMessage: String { pick(ko: "방장님이 스탭에서 해제했습니다.", en: "Host removed your staff role.", ja: "配信者があなたのスタッフ権限を解除しました。") }
        static func invitePrivateLiveMessage(_ nickname: String, _ shareUrl: String, _ password: String) -> String {
            pick(
                ko: "\(nickname)님이 귀하를 보이스온 비공개라이브에 초대하였습니다.\n※ 라이브 참여: \(shareUrl)\n(입장 비밀번호: \(password))",
                en: "\(nickname) invited you to a private VoiceOn live.\n※ Join live: \(shareUrl)\n(Entry password: \(password))",
                ja: "\(nickname)さんがあなたをVoiceOn非公開ライブに招待しました。\n※ ライブ参加: \(shareUrl)\n(入場パスワード: \(password))"
            )
        }
        static func invitePublicLiveMessage(_ nickname: String, _ shareUrl: String) -> String {
            pick(
                ko: "\(nickname)님이 귀하를 보이스온 공개라이브에 초대하였습니다.\n※ 라이브 참여: \(shareUrl)",
                en: "\(nickname) invited you to a public VoiceOn live.\n※ Join live: \(shareUrl)",
                ja: "\(nickname)さんがあなたをVoiceOn公開ライブに招待しました。\n※ ライブ参加: \(shareUrl)"
            )
        }

        static var leaveButton: String { pick(ko: "나가기", en: "Leave", ja: "退出") }
        static var endButton: String { pick(ko: "라이브 종료", en: "End live", ja: "ライブ終了") }
        static var changeListenerButton: String { pick(ko: "리스너 변경", en: "Switch to listener", ja: "リスナーへ変更") }

        static var signatureOn: String { pick(ko: "시그 ON", en: "Sign ON", ja: "シグ ON") }
        static var signatureOff: String { pick(ko: "시그 OFF", en: "Sign OFF", ja: "シグ OFF") }
        static var chatFreezeOn: String { pick(ko: "얼림 ON", en: "Freeze ON", ja: "凍結 ON") }
        static var chatFreezeOff: String { pick(ko: "얼림 OFF", en: "Freeze OFF", ja: "凍結 OFF") }
        static var captionOn: String { pick(ko: "자막 ON", en: "Caption ON", ja: "字幕 ON") }
        static var captionOff: String { pick(ko: "자막 OFF", en: "Caption OFF", ja: "字幕 OFF") }
        static var backgroundOn: String { pick(ko: "배경 ON", en: "Back ON", ja: "背景 ON") }
        static var backgroundOff: String { pick(ko: "배경 OFF", en: "Back OFF", ja: "背景 OFF") }
        static var notice: String { pick(ko: "공지", en: "Notice", ja: "お知らせ") }
        static var menuPan: String { pick(ko: "메뉴판", en: "Menu", ja: "メニュー表") }
        static var participants: String { pick(ko: "참여자", en: "Participants", ja: "リスナー") }
        static var follow: String { pick(ko: "팔로우", en: "Follow", ja: "フォロー") }
        static var following: String { pick(ko: "팔로잉", en: "Following", ja: "フォロー中") }
        static var chatFreezeOnStatusMessageForCreator: String { pick(ko: "“🧊 모두들 얼음!” 채팅창을 얼렸습니다.", en: "\"🧊 Freeze, everyone!\" The chat has been frozen.", ja: "「🧊 みんなフリーズ！」チャットを凍結しました。") }
        static var chatFreezeOnStatusMessageForListener: String { pick(ko: "“🧊 모두들 얼음!” 채팅창이 얼었습니다.", en: "\"🧊 Freeze, everyone!\" The chat is now frozen.", ja: "「🧊 みんなフリーズ！」チャットが凍結されました。") }
        static var chatFreezeOffStatusMessage: String { pick(ko: "“💧땡! “ 채팅창 얼리기가 해제되었습니다.", en: "\"💧 Ding!\" Chat freeze has been lifted.", ja: "「💧 たん！」チャット凍結が解除されました。") }
        static var chatFreezeBlockedMessage: String { pick(ko: "🧊 채팅창이 얼었습니다.", en: "🧊 The chat is now frozen.", ja: "🧊 チャットが凍結されました。") }
        static var chatInputPlaceholder: String { pick(ko: "채팅을 입력하세요", en: "Enter a chat message", ja: "チャットを入力してください") }
        static var chatDeleteTitle: String { pick(ko: "채팅 삭제", en: "Delete chat", ja: "チャット削除") }
    }

    enum LiveMain {
        static var createLiveButton: String {
            pick(ko: "라이브 만들기", en: "Create live", ja: "ライブを作成")
        }

        static var replaySectionTitle: String {
            pick(ko: "라이브 다시 듣기", en: "Live replay", ja: "ライブ再生")
        }
    }

    enum LiveNow {
        static var allTitle: String {
            pick(ko: "지금 라이브 중 전체보기", en: "Live Now - All", ja: "ライブ配信中（全て）")
        }

        static var sectionTitle: String {
            pick(ko: "지금 라이브중", en: "Live now", ja: "ライブ配信中")
        }

        static var remaining: String {
            pick(ko: "잔여", en: "Remaining", ja: "残り")
        }

        static var emptyStateMessage: String {
            pick(
                ko: "마이페이지에서 본인인증을 하거나\n라이브를 예약하고 참여해보세요.",
                en: "Verify your identity in My Page\nor reserve and join a live.",
                ja: "マイページで本人認証を行うか、\nライブを予約して参加してください。"
            )
        }

        static var refreshButton: String {
            pick(ko: "새로고침", en: "Refresh", ja: "更新")
        }

        static var followingChannelsTitle: String {
            pick(ko: "팔로잉 채널", en: "Following channels", ja: "フォロー中のチャンネル")
        }

        static var liveBadge: String {
            pick(ko: "Live", en: "Live", ja: "Live")
        }

        static var moreButton: String {
            pick(ko: "더보기", en: "More", ja: "もっと見る")
        }
    }

    enum LiveCancel {
        static var title: String {
            pick(ko: "예약취소", en: "Cancel reservation", ja: "予約キャンセル")
        }

        static var reasonPlaceholder: String {
            pick(
                ko: "취소사유를 입력하세요",
                en: "Enter a cancellation reason",
                ja: "キャンセル理由を入力してください"
            )
        }

        static var cancelButton: String {
            pick(ko: "취소", en: "Cancel", ja: "キャンセル")
        }

        static var confirmButton: String {
            pick(ko: "확인", en: "Confirm", ja: "確認")
        }

        static var reservationCanceled: String {
            pick(
                ko: "예약이 취소되었습니다.",
                en: "Reservation has been canceled.",
                ja: "予約がキャンセルされました。"
            )
        }
    }

    enum LiveReservation {
        enum Section {
            static var title: String {
                pick(ko: "라이브 예약중", en: "Live reservations", ja: "ライブ予約中")
            }

            static var emptyStateMessage: String {
                pick(
                    ko: "지금 예약중인 라이브가 없습니다.\n채널을 팔로잉 하고 라이브 알림을 받아 보세요.",
                    en: "There are no live reservations right now.\nFollow channels and receive live notifications.",
                    ja: "現在予約中のライブはありません。\nチャンネルをフォローしてライブ通知を受け取りましょう。"
                )
            }
        }

        enum All {
            static var title: String {
                pick(ko: "라이브, 예약 캘린더", en: "Live reservation calendar", ja: "ライブ予約カレンダー")
            }

            static var emptyStateMessage: String {
                pick(
                    ko: "지금 예약중인 라이브가 없습니다.\n다른 날짜의 라이브를 예약하고 참여해 보세요.",
                    en: "There are no live reservations right now.\nReserve a live on another date and join.",
                    ja: "現在予約中のライブはありません。\n別の日のライブを予約して参加してみてください。"
                )
            }
        }

        enum Item {
            static var reservationCompleted: String {
                pick(ko: "예약완료", en: "Reserved", ja: "予約完了")
            }

            static var ownCreatedLive: String {
                pick(ko: "내가 개설한 라이브", en: "Live I created", ja: "自分が開設したライブ")
            }

            static var free: String {
                CreateContent.free
            }

            static func month(_ value: String) -> String {
                pick(
                    ko: "\(value)월",
                    en: "\(value)M",
                    ja: "\(value)月"
                )
            }

            static func priceWithCan(_ can: Int) -> String {
                pick(
                    ko: "\(can)캔",
                    en: "\(can) cans",
                    ja: "\(can)can"
                )
            }
        }

        enum Complete {
            static var title: String {
                pick(ko: "라이브 예약 완료", en: "Live reservation complete", ja: "ライブ予約完了")
            }

            static var completedMessage: String {
                pick(ko: "예약이 완료되었습니다.", en: "Your reservation is complete.", ja: "予約が完了しました。")
            }

            static var reservationInfoTitle: String {
                pick(ko: "라이브 예약정보", en: "Reservation details", ja: "ライブ予約情報")
            }

            static var channelLabel: String {
                pick(ko: "채널", en: "Channel", ja: "チャンネル")
            }

            static var purchaseDetailLabel: String {
                pick(ko: "구매내역", en: "Purchase", ja: "購入内容")
            }

            static var reservationDateLabel: String {
                pick(ko: "예약일자", en: "Reservation date", ja: "予約日時")
            }

            static var liveCostLabel: String {
                pick(ko: "라이브 비용", en: "Live price", ja: "ライブ料金")
            }

            static var paymentInfoTitle: String {
                pick(ko: "결제정보", en: "Payment info", ja: "決済情報")
            }

            static var ownedCanLabel: String {
                pick(ko: "보유캔", en: "Owned cans", ja: "保有can")
            }

            static var paymentCanLabel: String {
                pick(ko: "결제캔", en: "Paid cans", ja: "決済can")
            }

            static var remainingCanLabel: String {
                pick(ko: "잔여캔", en: "Remaining cans", ja: "残りcan")
            }

            static var canSuffix: String {
                pick(ko: " 캔", en: " cans", ja: " can")
            }

            static var goHome: String {
                pick(ko: "홈으로 이동", en: "Go to Home", ja: "ホームへ移動")
            }

            static var goReservationList: String {
                pick(ko: "예약 내역 이동", en: "View reservations", ja: "予約履歴へ移動")
            }
        }
    }

    enum LiveChat {
        static var staffBadge: String {
            pick(ko: "스탭", en: "Staff", ja: "スタッフ")
        }

        static var rouletteResultQuestionSuffix: String {
            pick(ko: "님이 룰렛에 당첨된 건?", en: " hit on the roulette?", ja: "さんがルーレットで当たったのは？")
        }

        static var rouletteWinSuffix: String {
            pick(ko: " 당첨!", en: " won!", ja: " 当選！")
        }

        static var donationMemberSuffix: String {
            pick(ko: "님이", en: "", ja: "さんが")
        }

        static func canWithUnit(_ can: Int) -> String {
            pick(ko: "\(can)캔", en: "\(can) cans", ja: "\(can)can")
        }

        static var secretMissionDonationSuffix: String {
            pick(ko: "으로 비밀미션을 보냈습니다.🤫", en: " sent a secret mission.🤫", ja: "で秘密ミッションを送りました。🤫")
        }

        static var donationSuffix: String {
            pick(ko: "을 후원하셨습니다.💰🪙", en: " donated.💰🪙", ja: "を後援しました。💰🪙")
        }

        static var heartDonationSuffix: String {
            pick(ko: "'님이 마음을 전했습니다 : 💕", en: "' sent a heart : 💕", ja: "'さんがハートを送りました : 💕")
        }

        static var joinSuffix: String {
            pick(ko: "'님이 입장하셨습니다.", en: "' joined.", ja: "'さんが入場しました。")
        }
    }

    enum CreateContent {
        static var selectFile: String { pick(ko: "파일 선택", en: "Select file", ja: "ファイル選択") }
        static var selectTheme: String { pick(ko: "테마 선택", en: "Select theme", ja: "テーマ選択") }
        static var uploadContentDescriptionHint: String { pick(ko: "내용을 입력하세요", en: "Enter the details.", ja: "内容を入力してください") }
        static var uploadTitle: String { pick(ko: "콘텐츠 업로드", en: "Content upload", ja: "コンテンツ投稿") }
        static var uploadAction: String { pick(ko: "콘텐츠 업로드", en: "Upload content", ja: "コンテンツを投稿") }
        static var modifyTitle: String { pick(ko: "콘텐츠 수정", en: "Edit content", ja: "コンテンツ編集") }
        static var modifyAction: String { pick(ko: "수정", en: "Save changes", ja: "修正") }
        static var modifySuccess: String { pick(ko: "콘텐츠가 수정되었습니다.", en: "Content has been updated.", ja: "コンテンツが修正されました。") }
        static var registerTitle: String { pick(ko: "콘텐츠 등록", en: "Register content", ja: "コンテンツ登録") }
        static var thumbnail: String { pick(ko: "썸네일", en: "Thumbnail", ja: "サムネイル") }
        static var registerSectionTitle: String { pick(ko: "등록", en: "Upload", ja: "登録") }
        static var titleLabel: String { pick(ko: "제목", en: "Title", ja: "タイトル") }
        static var titlePlaceholder: String { pick(ko: "제목을 입력하세요", en: "Enter a title", ja: "タイトルを入力してください") }
        static var contentLabel: String { pick(ko: "내용", en: "Details", ja: "内容") }
        static func characterCount(_ count: Int) -> String { pick(ko: "\(count)자", en: "\(count) chars", ja: "\(count)文字") }
        static var max500CharactersSuffix: String { pick(ko: " / 최대 500자", en: " / Max 500 chars", ja: " / 最大500文字") }
        static var themeLabel: String { pick(ko: "테마", en: "Theme", ja: "テーマ") }
        static var tagLabel: String { pick(ko: "태그", en: "Tags", ja: "タグ") }
        static var tagPlaceholderExample: String { pick(ko: "예: #연애 #커버곡", en: "Ex: #romance #cover", ja: "例: #恋愛 #カバー曲") }
        static var priceSettingsTitle: String { pick(ko: "가격 설정", en: "Price settings", ja: "価格設定") }
        static var ownershipSettingsTitle: String { pick(ko: "소장 설정", en: "Ownership settings", ja: "購入設定") }
        static var rentPriceLabel: String { pick(ko: "대여 가격", en: "Rent price", ja: "レンタル価格") }
        static var purchasePriceLabel: String { pick(ko: "소장 가격", en: "Purchase price", ja: "購入価格") }
        static var priceInputPlaceholder: String { pick(ko: "가격을 입력하세요(5캔 이상)", en: "Enter price (5+ cans)", ja: "価格を入力してください（5can以上）") }
        static var canUnit: String { pick(ko: "캔", en: "cans", ja: "can") }
        static var rentalPeriodNotice: String { pick(ko: "※ 이용기간 대여 (5일) | 소장 (서비스종료시까지)", en: "※ Rental period (5 days) | Purchase (until service end)", ja: "※ 利用期間 レンタル（5日）｜購入（サービス終了時まで）") }
        static var rentalPriceAutoNotice: String { pick(ko: "※ 대여가격은 소장가격의 70%로 자동 반영", en: "※ Rent price is automatically set to 70% of purchase price", ja: "※ レンタル価格は購入価格の70%に自動反映されます") }
        static var minimumPriceNotice: String { pick(ko: "※ 콘텐츠의 최소금액은 5캔 입니다", en: "※ Minimum content price is 5 cans", ja: "※ コンテンツの最低価格は5canです") }
        static var limitedEditionSettingsTitle: String { pick(ko: "한정판 설정", en: "Limited edition settings", ja: "限定版設定") }
        static var limitedCountPlaceholder: String { pick(ko: "한정판 개수를 입력하세요", en: "Enter limited edition quantity", ja: "限定版の数量を入力してください") }
        static var pointUsageTitle: String { pick(ko: "포인트 사용", en: "Point usage", ja: "ポイント使用") }
        static var previewTitle: String { pick(ko: "미리듣기", en: "Preview", ja: "試聴") }
        static var previewTimeSettingsTitle: String { pick(ko: "미리듣기 시간 설정", en: "Preview time settings", ja: "試聴時間設定") }
        static var previewTimeGuide: String { pick(ko: "미리듣기 시간을 직접 설정하지 않으면 콘텐츠 앞부분 15초가 자동으로 설정됩니다. 미리듣기의 시간제한은 없습니다.", en: "If you do not set preview time manually, the first 15 seconds are set automatically. There is no limit on preview duration.", ja: "試聴時間を直接設定しない場合、コンテンツ冒頭15秒が自動設定されます。試聴時間に上限はありません。") }
        static var previewStartTimeLabel: String { pick(ko: "시작 시간", en: "Start time", ja: "開始時間") }
        static var previewEndTimeLabel: String { pick(ko: "종료 시간", en: "End time", ja: "終了時間") }
        static var ageRestrictionTitle: String { pick(ko: "연령 제한", en: "Age restriction", ja: "年齢制限") }
        static var adultLegalNotice: String { pick(ko: "성인콘텐츠를 전체관람가로 등록할 시 발생하는 법적 책임은 회사와 상관없이 콘텐츠를 등록한 본인에게 있습니다.\n콘텐츠 내용은 물론 제목도 19금 여부를 체크해 주시기 바랍니다.", en: "If adult content is registered as suitable for all ages, legal responsibility lies with the person who registered the content, not the company.\nPlease check whether both the content and title are age-restricted.", ja: "成人向けコンテンツを全年齢向けとして登録した場合に発生する法的責任は、会社ではなく登録者本人にあります。\nコンテンツ内容だけでなくタイトルの19禁該当可否も確認してください。") }
        static var commentAvailabilityTitle: String { pick(ko: "댓글 가능 여부", en: "Comment availability", ja: "コメント可否") }
        static var reservationDateLabel: String { pick(ko: "예약 날짜", en: "Reservation date", ja: "予約日") }
        static var reservationTimeLabel: String { pick(ko: "예약 시간", en: "Reservation time", ja: "予約時間") }
        static var registerButton: String { pick(ko: "등록", en: "Register", ja: "登録") }

        static var coverImageUploadFailed: String { pick(ko: "커버이미지를 업로드 하지 못했습니다.\n다시 선택해 주세요", en: "Failed to upload cover image.\nPlease select again.", ja: "カバー画像をアップロードできませんでした。\nもう一度選択してください。") }
        static var contentFileUploadFailed: String { pick(ko: "콘텐츠 파일을 업로드 하지 못했습니다.\n다시 선택해 주세요", en: "Failed to upload content file.\nPlease select again.", ja: "コンテンツファイルをアップロードできませんでした。\nもう一度選択してください。") }
        static var titleRequired: String { pick(ko: "제목을 입력해 주세요.", en: "Please enter a title.", ja: "タイトルを入力してください。") }
        static var detailMinLengthRequired: String { pick(ko: "내용을 5자 이상 입력해 주세요.", en: "Please enter at least 5 characters for details.", ja: "内容を5文字以上入力してください。") }
        static var themeRequired: String { pick(ko: "테마를 선택해 주세요.", en: "Please select a theme.", ja: "テーマを選択してください。") }
        static var coverImageRequired: String { pick(ko: "커버이미지를 선택해 주세요.", en: "Please select a cover image.", ja: "カバー画像を選択してください。") }
        static var audioContentRequired: String { pick(ko: "오디오 콘텐츠를 선택해 주세요.", en: "Please select audio content.", ja: "オーディオコンテンツを選択してください。") }
        static var minimumPriceRequired: String { pick(ko: "콘텐츠의 최소금액은 5캔 입니다.", en: "Minimum content price is 5 cans.", ja: "コンテンツの最低価格は5canです。") }
        static var previewTimeFormatInvalid: String { pick(ko: "미리 듣기 시간 형식은 00:30:00 과 같아야 합니다", en: "Preview time format must be like 00:30:00", ja: "試聴時間の形式は00:30:00のようである必要があります") }
        static var previewMinimumDurationError: String { pick(ko: "미리 듣기의 최소 시간은 15초 입니다", en: "Minimum preview duration is 15 seconds", ja: "試聴の最小時間は15秒です") }
        static var previewStartEndBothOrNone: String { pick(ko: "미리 듣기 시작 시간과 종료 시간 둘 다 입력을 하거나 둘 다 입력 하지 않아야 합니다.", en: "Enter both preview start and end times, or leave both empty.", ja: "試聴の開始時間と終了時間は両方入力するか、両方未入力にしてください。") }
        static var uploadDescription: String {
            pick(
                ko: "등록한 콘텐츠가 업로드 중입니다.\n콘텐츠 등록이 완료되면 알림을 보내드립니다.\n이 페이지를 나가도 콘텐츠는 자동으로 등록됩니다.",
                en: "Your content is being uploaded.\nWe will notify you when the upload is complete.\nYou can leave this page and the content will still be registered.",
                ja: "登録したコンテンツはアップロード中です。\nアップロードが完了すると通知します。\nこのページを離れても自動で登録されます。"
            )
        }

        // 가격/구매 옵션
        static var free: String { pick(ko: "무료", en: "Free", ja: "無料") }
        static var paid: String { pick(ko: "유료", en: "Paid", ja: "有料") }
        static var purchaseBoth: String { pick(ko: "소장/대여", en: "Buy/Rent", ja: "購入/レンタル") }
        static var purchaseBuyOnly: String { pick(ko: "소장만", en: "Buy only", ja: "購入のみ") }
        static var purchaseRentOnly: String { pick(ko: "대여만", en: "Rent only", ja: "レンタルのみ") }
        static var unlimited: String { pick(ko: "무제한", en: "Unlimited", ja: "無制限") }
        static var limitedEdition: String { pick(ko: "한정판", en: "Limited", ja: "限定版") }

        // 포인트 사용
        static var available: String { pick(ko: "가능", en: "Available", ja: "可能") }
        static var unavailable: String { pick(ko: "불가능", en: "Unavailable", ja: "不可") }

        // 미리듣기
        static var generate: String { pick(ko: "생성", en: "Generate", ja: "生成") }
        static var doNotGenerate: String { pick(ko: "생성 안 함", en: "Do not generate", ja: "生成しない") }

        // 연령 제한
        static var allAges: String { pick(ko: "전체 연령", en: "All ages", ja: "全年齢") }
        static var over19: String { pick(ko: "19세 이상", en: "19+", ja: "R-18") }

        // 댓글 가능 여부
        static var commentAllowed: String { pick(ko: "댓글 가능", en: "Comments allowed", ja: "コメント可") }
        static var commentNotAllowed: String { pick(ko: "댓글 불가", en: "Comments not allowed", ja: "コメント不可") }

        // 공개 설정
        static var publishNow: String { pick(ko: "지금 공개", en: "Publish now", ja: "今すぐ公開") }
        static var publishReserved: String { pick(ko: "예약 공개", en: "Scheduled", ja: "予約公開") }
    }

    enum Playlist {
        static var deleteTitle: String {
            pick(ko: "재생 목록 삭제", en: "Delete playlist", ja: "プレイリストを削除")
        }

        static func deleteQuestion(_ title: String) -> String {
            pick(
                ko: "\(title)을 삭제하시겠습니까?",
                en: "Do you want to delete \(title)?",
                ja: "\(title)を削除しますか？"
            )
        }

        static var deleteCompleted: String {
            pick(ko: "삭제되었습니다.", en: "Deleted.", ja: "削除されました。")
        }
    }

    enum Category {
        static var all: String { pick(ko: "전체", en: "All", ja: "全") }
    }

    enum RankingSort {
        // 분석/지표 등
        static var revenue: String { pick(ko: "매출", en: "Revenue", ja: "売上高") }
        static var salesVolume: String { pick(ko: "판매량", en: "Units", ja: "販売量") }
        static var comments: String { pick(ko: "댓글", en: "Comments", ja: "コメント") }
        static var likes: String { pick(ko: "좋아요", en: "Likes", ja: "いいね") }
    }
    
    enum DonationRanking {
        static var weekly: String { pick(ko: "주간", en: "Weekly", ja: "週間") }
        static var cumulative: String { pick(ko: "누적", en: "Cumulative", ja: "累計") }
    }

    enum Tab {
        // 탭/도메인
        static var character: String { pick(ko: "캐릭터", en: "Character", ja: "キャラクター") }
        static var work: String { pick(ko: "작품별", en: "By Original", ja: "作品別") }
        static var talk: String { pick(ko: "톡", en: "Chat", ja: "トーク") }
        static var workInfo: String { pick(ko: "작품정보", en: "Work info", ja: "作品情報") }

        static var detail: String { pick(ko: "상세", en: "Details", ja: "詳細") }
        static var gallery: String { pick(ko: "갤러리", en: "Gallery", ja: "ギャラリー") }
    }

    enum MemberChannel {
        // 팔로우 알림 설정 다이얼로그용
        static var all: String { pick(ko: "모두 알림", en: "All notifications", ja: "すべて通知") }
        static var none: String { pick(ko: "알림 없음", en: "No notifications", ja: "通知なし") }
        static var unfollow: String { pick(ko: "팔로우 취소", en: "Unfollow", ja: "フォロー解除") }
        static var unfollowConfirmTitle: String { pick(ko: "팔로우 해제", en: "Unfollow", ja: "フォロー解除") }
        static func unfollowConfirmDescription(_ nickname: String) -> String {
            pick(
                ko: "\(nickname)님을 팔로우 해제 하시겠습니까?",
                en: "Do you want to unfollow \(nickname)?",
                ja: "\(nickname)さんのフォローを解除しますか？"
            )
        }

        static var liveOnNow: String { pick(ko: "현재 라이브 중입니다.", en: "Live is currently ongoing.", ja: "現在ライブ配信中です。") }
        static var cannotReserveOwnLive: String { pick(ko: "내가 만든 라이브는 예약할 수 없습니다.", en: "reserve a live you created is required.", ja: "自分が作ったライブは予約できません。") }
        static var enterLiveFailed: String { pick(ko: "라이브에 입장하지 못했습니다.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.", en: "Could not enter the live.\nIf the problem persists, please contact customer support.", ja: "ライブに入室できませんでした。\n問題が続く場合はカスタマーサポートにお問い合わせください。") }
        static var fetchLiveInfoFailed: String { pick(ko: "라이브 정보를 가져오지 못했습니다.\n다시 시도해 주세요.", en: "Failed to fetch live information.\nPlease try again.", ja: "ライブ情報を取得できませんでした。\nもう一度お試しください。") }
        static var alreadyEndedLive: String { pick(ko: "이미 종료된 라이브 입니다.", en: "This live has already ended.", ja: "このライブはすでに終了しています。") }
        static var userBlocked: String { pick(ko: "차단하였습니다.", en: "User has been blocked.", ja: "ブロックしました。") }
        static var userUnblocked: String { pick(ko: "차단이 해제 되었습니다.", en: "User has been unblocked.", ja: "ブロックを解除しました。") }
        static var blockDialogTitle: String { pick(ko: "사용자 차단", en: "Block User", ja: "ユーザーブロック") }
        static func blockConfirmQuestion(_ nickname: String) -> String {
            pick(
                ko: "\(nickname)님을 차단하시겠습니까?",
                en: "Do you want to block \(nickname)?",
                ja: "\(nickname)さんをブロックしますか？"
            )
        }
        static func blockCreatorNotice(_ nickname: String) -> String {
            pick(
                ko: """
사용자를 차단하면 해당 사용자는 아래 기능이 제한됩니다.

- 내 채널 접근 제한
- 내가 개설한 라이브 입장 불가
- 내가 등록한 콘텐츠 접근 불가
- 나에게 메시지 보내기 불가
- \(nickname)님이 작성한 댓글보기 제한
- \(nickname)님의 라이브 채팅보기 제한
""",
                en: """
If you block this user, the following features will be restricted for that user.

- Access to my channel restricted
- Cannot enter live streams I created
- Cannot access content I registered
- Cannot send me messages
- Restricted from viewing comments written by \(nickname)
- Restricted from viewing \(nickname)'s live chats
""",
                ja: """
このユーザーをブロックすると、以下の機能がそのユーザーに対して制限されます。

- 私のチャンネルへのアクセス制限
- 私が開設したライブへの入場不可
- 私が登録したコンテンツへのアクセス不可
- 私へのメッセージ送信不可
- \(nickname)さんが作成したコメントの閲覧制限
- \(nickname)さんのライブチャット閲覧制限
"""
            )
        }
        static func blockListenerNotice(_ nickname: String) -> String {
            pick(
                ko: """
사용자를 차단하면 아래 기능이 제한됩니다.

- \(nickname)님의 채널 접근 제한
- \(nickname)님의 콘텐츠 보기 제한
- \(nickname)님의 라이브 보기 제한
- \(nickname)님에게 메시지 보내기 제한
- \(nickname)님이 작성한 댓글보기 제한
- \(nickname)님의 라이브 채팅보기 제한
""",
                en: """
If you block this user, the following features will be restricted.

- Access to \(nickname)'s channel restricted
- Restricted from viewing \(nickname)'s content
- Restricted from viewing \(nickname)'s live streams
- Restricted from sending messages to \(nickname)
- Restricted from viewing comments written by \(nickname)
- Restricted from viewing \(nickname)'s live chats
""",
                ja: """
このユーザーをブロックすると、以下の機能が制限されます。

- \(nickname)さんのチャンネルへのアクセス制限
- \(nickname)さんのコンテンツ閲覧制限
- \(nickname)さんのライブ閲覧制限
- \(nickname)さんへのメッセージ送信制限
- \(nickname)さんが作成したコメントの閲覧制限
- \(nickname)さんのライブチャット閲覧制限
"""
            )
        }
        static var blockAction: String { pick(ko: "차단", en: "Block", ja: "ブロック") }
        static var shareLinkCreateFailed: String { pick(ko: "공유링크를 생성하지 못했습니다.\n다시 시도해 주세요.", en: "Failed to create a share link.\nPlease try again.", ja: "共有リンクを作成できませんでした。\nもう一度お試しください。") }

        static var cheersDeleteTitle: String { pick(ko: "응원글 삭제", en: "Delete Cheer", ja: "応援削除") }

        static var channelDonationHeader: String { pick(ko: "채널 후원", en: "Channel Donation", ja: "チャンネル支援") }
        static var channelDonationButton: String { pick(ko: "채널 후원하기", en: "Donate to Channel", ja: "チャンネルを支援する") }
        static var secretDonationLabel: String { pick(ko: "비밀후원", en: "Secret donation", ja: "シークレット支援") }
        static var secretDonationMinimumCanMessage: String {
            pick(
                ko: "비밀 후원은 최소 10캔 이상부터 이용이 가능합니다.",
                en: "Secret donation is available from at least 10 cans.",
                ja: "シークレット支援は最低10canから利用できます。"
            )
        }
        static var channelDonationEmpty: String { pick(ko: "채널 후원이 없습니다.", en: "No channel donations.", ja: "チャンネル支援はありません。") }
        static var channelDonationAllTitle: String { pick(ko: "채널 후원 전체보기", en: "All Channel Donations", ja: "チャンネル支援一覧") }
        static var totalLabel: String { pick(ko: "전체", en: "Total", ja: "全体") }
        static var countUnit: String { pick(ko: "개", en: "items", ja: "件") }
        static var channelDonationDefaultMessage: String { pick(ko: "을 후원했습니다.", en: " donated.", ja: "を支援しました。") }

        static var liveHeader: String { pick(ko: "라이브", en: "Live", ja: "ライブ") }
        static var rouletteSettings: String { pick(ko: "룰렛 설정", en: "Roulette settings", ja: "ルーレット設定") }
        static var menuSettings: String { pick(ko: "메뉴 설정", en: "Menu settings", ja: "メニュー設定") }
        static var communityHeader: String { pick(ko: "커뮤니티", en: "Community", ja: "コミュニティ") }
        static var followersList: String { pick(ko: "팔로워 리스트", en: "Followers list", ja: "フォロワーリスト") }
        static var followerCount: (String) -> String = { count in
            pick(ko: "팔로워 \(count)명", en: "\(count) followers", ja: "フォロワー\(count)人")
        }
        static var followerCountWithDetail: (String) -> String = { count in
            pick(ko: "팔로워 \(count)명 · 상세정보 >", en: "\(count) followers · Details >", ja: "フォロワー\(count)人 ・ 詳細情報 >")
        }
        static var creatorDetailDebut: String { pick(ko: "데뷔", en: "Debut", ja: "デビュー") }
        static var creatorDetailTotalLiveCount: String { pick(ko: "라이브 총 횟수", en: "Total live sessions", ja: "ライブ総回数") }
        static var creatorDetailAccumulatedLiveTime: String { pick(ko: "라이브 누적 시간", en: "Total live time", ja: "ライブ累積時間") }
        static var creatorDetailAccumulatedParticipants: String { pick(ko: "라이브 누적 참여자", en: "Total live participants", ja: "ライブ累積参加者") }
        static var creatorDetailRegisteredContentCount: String { pick(ko: "등록 콘텐츠 수", en: "Registered contents", ja: "登録コンテンツ数") }
        static var creatorDetailSns: String { pick(ko: "SNS", en: "SNS", ja: "SNS") }
        static var preDebut: String { pick(ko: "데뷔전", en: "Pre-debut", ja: "デビュー前") }

        static func channelTitle(_ nickname: String) -> String {
            pick(ko: "\(nickname)님의 채널", en: "\(nickname)'s channel", ja: "\(nickname)のチャンネル")
        }

        static func shareChannelMessage(_ nickname: String) -> String {
            pick(ko: "보이스온 \(nickname)님의 채널입니다.", en: "This is \(nickname)'s channel on VoiceOn.", ja: "ボイスオンの\(nickname)さんのチャンネルです。")
        }

        static func reserveWithCansTitle(_ price: Int) -> String {
            pick(ko: "\(price)캔으로 예약", en: "Reserve with \(price) cans", ja: "\(price)canで予約")
        }

        static func reservePaymentDesc(_ title: String) -> String {
            pick(ko: "'\(title)' 라이브에 참여하기 위해 결제합니다.", en: "Payment is required to join '\(title)' live.", ja: "『\(title)』ライブに参加するには決済が必要です。")
        }

        static var reservePaymentConfirmTitle: String { pick(ko: "결제 후 예약하기", en: "Pay and reserve", ja: "決済して予約") }

        static var paidLiveEnterTitle: String { pick(ko: "유료 라이브 입장", en: "Enter paid live", ja: "有料ライブ入室") }
        static func paidLiveEnterDesc(_ price: Int) -> String {
            pick(ko: "\(price)캔을 차감하고\n라이브에 입장 하시겠습니까?", en: "\(price) cans will be used.\nDo you want to enter the live?", ja: "\(price)canが消費されます。\nライブに入場しますか？")
        }
        static var paidLiveConfirmTitle: String { pick(ko: "결제 후 참여하기", en: "Pay and join", ja: "決済して参加") }

        static func elapsedLiveWarning(hours: Int, minutes: Int) -> String {
            pick(
                ko: "라이브를 시작한 지 \(hours)시간 \(minutes)분이 지났습니다. 라이브에 입장 후 30분 이내에 라이브가 종료될 수도 있습니다.",
                en: "It has been \(hours) hour(s) and \(minutes) minute(s) since the live started. The live may end within 30 minutes after you enter.",
                ja: "ライブ開始から\(hours)時間\(minutes)分が経過しています。入場後30分以内に終了する場合があります。"
            )
        }
    }

    enum ImagePicker {
        static var cropResizeGuide: String {
            pick(
                ko: "모서리 원을 드래그해서 크롭 영역 크기를 조정하세요",
                en: "Drag the corner handles to resize the crop area.",
                ja: "角のハンドルをドラッグしてクロップ範囲のサイズを調整してください。"
            )
        }
    }

    enum CustomView {
        static var collapse: String {
            pick(ko: "접기", en: "Collapse", ja: "閉じる")
        }

        static var expand: String {
            pick(ko: "펼치기", en: "Expand", ja: "展開")
        }
    }

    enum IAP {
        static var loadProductsFailed: String {
            pick(
                ko: "상품을 불러오지 못했습니다.\n다시 시도해 주세요.",
                en: "Could not load products.\nPlease try again.",
                ja: "商品を読み込めませんでした。\nもう一度お試しください。"
            )
        }

        static var deferredPaymentFailed: String {
            pick(
                ko: "아이폰이 잠김 등의 이유로 결제를 진행하지 못했습니다.",
                en: "Could not proceed with payment because the iPhone is locked.",
                ja: "iPhoneがロックされているなどの理由で決済を進められませんでした。"
            )
        }

        static var productValidationCompleted: String {
            pick(
                ko: "상품 검증을 하였습니다.",
                en: "Product validation is complete.",
                ja: "商品検証が完了しました。"
            )
        }

        static var unknownError: String {
            pick(
                ko: "알 수 없는 오류가 발생했습니다.",
                en: "An unknown error occurred.",
                ja: "不明なエラーが発生しました。"
            )
        }

        static var paymentFailed: String {
            pick(
                ko: "결제를 진행하지 못했습니다.\n다시 시도해 주세요.",
                en: "Could not complete payment.\nPlease try again.",
                ja: "決済を完了できませんでした。\nもう一度お試しください。"
            )
        }
    }

    enum Follow {
        static var followingListTitle: String {
            pick(ko: "팔로잉 리스트", en: "Following list", ja: "フォロー中リスト")
        }

        static var totalPrefix: String {
            pick(ko: "총", en: "Total", ja: "合計")
        }

        static var personUnit: String {
            pick(ko: "명", en: "people", ja: "人")
        }

        static var emptyFollowingChannels: String {
            pick(
                ko: "팔로우 중인 채널이 없습니다.",
                en: "There are no channels you follow.",
                ja: "フォロー中のチャンネルがありません。"
            )
        }
    }

    enum Main {
        enum EventPopup {
            static var doNotShowAgain: String {
                pick(ko: "다시보지 않기", en: "Don't show again", ja: "今後表示しない")
            }

            static var close: String {
                pick(ko: "닫기", en: "Close", ja: "閉じる")
            }
        }

        enum Tab {
            static var home: String { pick(ko: "홈", en: "Home", ja: "ホーム") }
            static var live: String { pick(ko: "라이브", en: "Live", ja: "ライブ") }
            static var chat: String { pick(ko: "채팅", en: "Chat", ja: "チャット") }
            static var my: String { pick(ko: "마이", en: "My", ja: "マイ") }
        }

        enum Auth {
            static var dialogTitle: String {
                pick(ko: "본인인증", en: "Identity verification", ja: "本人認証")
            }

            static var liveEntryVerificationDescription: String {
                pick(
                    ko: "청소년 보호를 위해\n본인인증을 완료한\n성인만 라이브 입장이 가능합니다.\n라이브 입장을 위해\n본인인증을 진행해 주세요.",
                    en: "Only adults who completed identity verification can enter live rooms for youth protection.\nPlease complete identity verification to enter live.",
                    ja: "青少年保護のため、本人認証を完了した成人のみライブに入場できます。\nライブ入場のために本人認証を行ってください。"
                )
            }

            static var goToVerification: String {
                pick(ko: "본인인증 하러가기", en: "Verify identity", ja: "本人認証へ")
            }

            static var authenticationError: String {
                pick(
                    ko: "본인인증 중 오류가 발생했습니다.",
                    en: "An error occurred during identity verification.",
                    ja: "本人認証中にエラーが発生しました。"
                )
            }
        }
    }

    enum Home {
        static var liveNowSectionTitle: String {
            pick(ko: "지금 라이브중", en: "Live now", ja: "ライブ配信中")
        }

        static var popularCreatorSectionTitle: String {
            pick(ko: "인기 크리에이터", en: "Popular creators", ja: "人気クリエイター")
        }

        static var onlyOnVoiceOnSectionTitle: String {
            pick(ko: "오직 보이스온에서만", en: "Only on VoiceOn", ja: "VoiceOnだけで")
        }

        static var popularCharacterChatSectionTitle: String {
            pick(ko: "인기 캐릭터 채팅", en: "Popular character chats", ja: "人気キャラクターチャット")
        }

        static var recommendChannelSectionTitle: String {
            pick(ko: "추천 채널", en: "Recommended channels", ja: "おすすめチャンネル")
        }

        static var freeContentSectionTitle: String {
            pick(ko: "무료 콘텐츠", en: "Free content", ja: "無料コンテンツ")
        }

        static var pointRentalContentSectionTitle: String {
            pick(ko: "포인트 대여 콘텐츠", en: "Point rental content", ja: "ポイントレンタルコンテンツ")
        }

        static var recommendContentSectionTitle: String {
            pick(ko: "추천 콘텐츠", en: "Recommended content", ja: "おすすめコンテンツ")
        }

        static var weeklyChartSectionTitle: String {
            pick(ko: "보온 주간 차트", en: "VoiceOn weekly chart", ja: "ボイスオン週間チャート")
        }

        enum RecommendChannel {
            static var contentLabel: String {
                pick(ko: "콘텐츠", en: "Content", ja: "コンテンツ")
            }
        }
    }

    enum Explorer {
        static var channel: String {
            pick(ko: "채널", en: "Channel", ja: "チャンネル")
        }

        static var searchChannelPlaceholder: String {
            pick(ko: "채널명을 입력해 보세요", en: "Search channel name", ja: "チャンネル名を入力してください")
        }

        static var searchEmptyResult: String {
            pick(ko: "검색 결과가 없습니다.", en: "No search results.", ja: "検索結果がありません。")
        }

        static var rankingWeeklyUpdateNotice: String {
            pick(ko: "※ 인기 크리에이터의 순위는 매주 업데이트됩니다.", en: "※ Popular creator rankings are updated weekly.", ja: "※ 人気クリエイターのランキングは毎週更新されます。")
        }

        static var communityTitle: String {
            pick(ko: "커뮤니티", en: "Community", ja: "コミュニティ")
        }

        static var viewMore: String {
            pick(ko: "더보기", en: "More", ja: "もっと見る")
        }

        static var secretComment: String {
            pick(ko: "비밀댓글", en: "Secret comment", ja: "秘密コメント")
        }

        static var commentInputPlaceholder: String {
            pick(ko: "댓글을 입력해 보세요.", en: "Enter a comment.", ja: "コメントを入力してください。")
        }

        static var replyTitle: String {
            pick(ko: "답글", en: "Replies", ja: "返信")
        }

        static var replyWrite: String {
            pick(ko: "답글 쓰기", en: "Write reply", ja: "返信を書く")
        }

        static func replyCount(_ count: Int) -> String {
            pick(ko: "답글 \(count)개", en: "\(count) replies", ja: "返信\(count)件")
        }

        static var edit: String {
            pick(ko: "수정", en: "Edit", ja: "編集")
        }

        static var report: String {
            pick(ko: "신고", en: "Report", ja: "通報")
        }

        static var reportAction: String {
            pick(ko: "신고하기", en: "Report", ja: "通報する")
        }

        static var noChanges: String {
            pick(ko: "변경사항이 없습니다.", en: "No changes.", ja: "変更事項がありません。")
        }

        static var inputContent: String {
            pick(ko: "내용을 입력하세요", en: "Enter content.", ja: "内容を入力してください。")
        }

        static var inputContentWithPeriod: String {
            pick(ko: "내용을 입력하세요.", en: "Enter content.", ja: "内容を入力してください。")
        }

        static func minContentLength(_ count: Int) -> String {
            pick(ko: "내용을 \(count)자 이상 입력해 주세요.", en: "Please enter at least \(count) characters.", ja: "内容を\(count)文字以上入力してください。")
        }

        static var deleted: String {
            pick(ko: "삭제되었습니다", en: "Deleted.", ja: "削除されました。")
        }

        static var imageLoadFailed: String {
            pick(ko: "이미지를 로드하지 못했습니다.", en: "Could not load the image.", ja: "画像を読み込めませんでした。")
        }

        static var postCreated: String {
            pick(ko: "게시물이 등록되었습니다.", en: "Post has been created.", ja: "投稿が登録されました。")
        }

        static var postUpdated: String {
            pick(ko: "게시물이 수정되었습니다.", en: "Post has been updated.", ja: "投稿が修正されました。")
        }

        static var minPriceFiveCans: String {
            pick(ko: "최소금액은 5캔 입니다.", en: "The minimum price is 5 cans.", ja: "最低金額は5canです。")
        }

        static var pinRelease: String {
            pick(ko: "고정 해제", en: "Unpin", ja: "固定解除")
        }

        static var pinToTop: String {
            pick(ko: "최상단에 고정", en: "Pin to top", ja: "最上部に固定")
        }

        static func viewPostWithCans(_ can: Int) -> String {
            pick(ko: "\(can)캔으로 게시글 보기", en: "View post with \(can) cans", ja: "\(can)canで投稿を見る")
        }

        static var postRegister: String {
            pick(ko: "게시물 등록", en: "Create post", ja: "投稿登録")
        }

        static var postRegisterDescription: String {
            pick(ko: "게시 후에 게시물이 여기에 표시되고\n커뮤니티에 공개됩니다.", en: "After posting, your post appears here\nand is published to the community.", ja: "投稿後、ここに表示され\nコミュニティに公開されます。")
        }

        static var postWriteTitle: String {
            pick(ko: "게시글 등록", en: "Create post", ja: "投稿登録")
        }

        static var postModifyTitle: String {
            pick(ko: "게시글 수정", en: "Edit post", ja: "投稿修正")
        }

        static var imageTitle: String {
            pick(ko: "이미지", en: "Image", ja: "画像")
        }

        static var imageOptionalNotice: String {
            pick(ko: "등록할 이미지가 없으면 이미지 없이 게시글만 등록 하셔도 됩니다.", en: "If there is no image to upload, you can post without an image.", ja: "登録する画像がない場合、画像なしで投稿できます。")
        }

        static var contentTitle: String {
            pick(ko: "내용", en: "Content", ja: "内容")
        }

        static var contentCharacterUnit: String {
            pick(ko: "자", en: "", ja: "文字")
        }

        static var max500Chars: String {
            pick(ko: " / 최대 500자", en: " / up to 500 chars", ja: " / 最大500文字")
        }

        static var commentAvailability: String {
            pick(ko: "댓글 가능 여부", en: "Comment availability", ja: "コメント可否")
        }

        static var ageRestriction: String {
            pick(ko: "연령 제한", en: "Age restriction", ja: "年齢制限")
        }

        static var priceSetting: String {
            pick(ko: "가격 설정", en: "Price setting", ja: "価格設定")
        }

        static var close: String {
            pick(ko: "닫기", en: "Close", ja: "閉じる")
        }

        static var register: String {
            pick(ko: "등록", en: "Register", ja: "登録")
        }

        static var modify: String {
            pick(ko: "수정", en: "Edit", ja: "編集")
        }

        static var recordingDefaultFileName: String {
            pick(ko: "녹음", en: "Recording", ja: "録音")
        }

        static var recordingTitle: String {
            pick(ko: "음성녹음", en: "Voice recording", ja: "音声録音")
        }

        static var recordAgain: String {
            pick(ko: "다시 녹음", en: "Record again", ja: "再録音")
        }

        static var recordingComplete: String {
            pick(ko: "녹음완료", en: "Done recording", ja: "録音完了")
        }

        static var recordingPermissionDenied: String {
            pick(ko: "권한을 허용하지 않으시면 음성녹음을 하실 수 없습니다.", en: "Voice recording is unavailable without permission.", ja: "権限を許可しないと音声録音を利用できません。")
        }

        static var recordingFileCreateFailed: String {
            pick(ko: "녹음파일을 생성하지 못했습니다.\n다시 시도해 주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.", en: "Could not create the recording file.\nPlease try again.\nIf the issue persists, contact customer support.", ja: "録音ファイルを作成できませんでした。\nもう一度お試しください。\n問題が続く場合はカスタマーサポートにお問い合わせください。")
        }

        static var audioRecordingTitle: String {
            pick(ko: "오디오 녹음", en: "Audio recording", ja: "オーディオ録音")
        }

        static var audioRecordingMax3Minutes: String {
            pick(ko: "※ 오디오 녹음은 최대 3분입니다", en: "※ Audio recording is limited to 3 minutes.", ja: "※ オーディオ録音は最大3分です。")
        }

        static var fanTalkTitle: String {
            pick(ko: "팬 Talk", en: "Fan Talk", ja: "ファントーク")
        }

        static var fanTalkAllTitle: String {
            pick(ko: "팬 Talk 전체보기", en: "All Fan Talk", ja: "ファントーク一覧")
        }

        static var cheerTitle: String {
            pick(ko: "응원", en: "Cheer", ja: "応援")
        }

        static var cheerInputPlaceholder: String {
            pick(ko: "응원댓글을 입력하세요", en: "Enter a cheer comment", ja: "応援コメントを入力してください")
        }

        static var cheerEmpty: String {
            pick(ko: "응원이 없습니다.\n\n처음으로 응원을 해보세요!", en: "No cheers yet.\n\nBe the first to cheer!", ja: "応援がありません。\n\n最初の応援をしてみましょう！")
        }

        static var cheerReplyPlaceholder: String {
            pick(ko: "응원댓글에 답글을 남겨보세요!", en: "Leave a reply to this cheer!", ja: "応援コメントに返信してみましょう！")
        }

        static var replyEdit: String {
            pick(ko: "답글 수정", en: "Edit reply", ja: "返信を編集")
        }

        static var seriesTitle: String {
            pick(ko: "시리즈", en: "Series", ja: "シリーズ")
        }

        static var channelIntroduceTitle: String {
            pick(ko: "채널 소개", en: "Channel intro", ja: "チャンネル紹介")
        }

        static var donationRankingTitle: String {
            pick(ko: "후원랭킹", en: "Donation ranking", ja: "後援ランキング")
        }

        static var donationRankingAllTitle: String {
            pick(ko: "후원랭킹 전체보기", en: "All donation rankings", ja: "後援ランキング一覧")
        }

        static var donationRankActivation: String {
            pick(ko: "채널에 후원랭킹 활성화", en: "Enable donation ranking on channel", ja: "チャンネルで後援ランキングを有効化")
        }

        static var donationRankActivationNotice: String {
            pick(ko: "※ 비활성화하면 채널 내 후원랭킹이 표시되지 않으며,\n라이브 중에도 후원랭킹에 따른 뱃지가 반영되지 않습니다.", en: "※ If disabled, donation ranking is hidden in your channel, and ranking badges are not reflected during live.", ja: "※ 無効にするとチャンネル内に後援ランキングが表示されず、ライブ中のランキングバッジも反映されません。")
        }

        static var today: String {
            pick(ko: "오늘", en: "Today", ja: "今日")
        }

        static var lastWeek: String {
            pick(ko: "지난주", en: "Last week", ja: "先週")
        }

        static var thisMonthUntilYesterday: String {
            pick(ko: "이번 달 어제까지", en: "This month until yesterday", ja: "今月（昨日まで）")
        }

        static var canUnitWithSpace: String {
            pick(ko: " 캔", en: " cans", ja: " can")
        }

        static var canUnitCompact: String {
            pick(ko: "캔", en: "cans", ja: "can")
        }

        static func canWithSpace(_ can: Int) -> String {
            pick(ko: "\(can) 캔", en: "\(can) cans", ja: "\(can)can")
        }

        static var myContent: String {
            pick(ko: "내 콘텐츠", en: "My content", ja: "マイコンテンツ")
        }

        static var content: String {
            pick(ko: "콘텐츠", en: "Content", ja: "コンテンツ")
        }

        static var createNewContent: String {
            pick(ko: "새로운 콘텐츠 등록하기", en: "Create new content", ja: "新しいコンテンツを登録")
        }

        static func ownedPercentage(_ percentage: Int) -> String {
            pick(ko: "\(percentage)% 보유중", en: "\(percentage)% owned", ja: "\(percentage)%保有中")
        }

        static var noOwnedContent: String {
            pick(ko: "소장 중인 작품이 없어요!", en: "No owned works yet!", ja: "所蔵中の作品がありません！")
        }

        static func totalContentCount(_ count: Int) -> String {
            pick(ko: "\(count)개", en: "\(count)", ja: "\(count)件")
        }

        static func month(_ value: String) -> String {
            pick(ko: "\(value)월", en: "\(value)", ja: "\(value)月")
        }

        static var reservationDone: String {
            pick(ko: "예약완료", en: "Reserved", ja: "予約完了")
        }

        static var activityLiveCount: String {
            pick(ko: "라이브\n횟수", en: "Live\ncount", ja: "ライブ\n回数")
        }

        static var activityLiveTime: String {
            pick(ko: "라이브\n시간", en: "Live\ntime", ja: "ライブ\n時間")
        }

        static var activityLiveParticipants: String {
            pick(ko: "라이브\n참여자", en: "Live\nparticipants", ja: "ライブ\n参加者")
        }

        static var activityRegisteredContent: String {
            pick(ko: "등록\n콘텐츠", en: "Registered\ncontent", ja: "登録\nコンテンツ")
        }
    }

    enum Dialog {
        enum ApplyAuditionComplete {
            static var thankYouDescription: String {
                pick(
                    ko: "보이스온 오디션에 지원해 주셔서 감사합니다.",
                    en: "Thank you for applying to the VoiceOn audition.",
                    ja: "VoiceOnオーディションにご応募いただきありがとうございます。"
                )
            }
        }

        enum CommunityPostPurchase {
            static var title: String {
                pick(ko: "게시글 보기", en: "View post", ja: "投稿を見る")
            }

            static var description: String {
                pick(
                    ko: "게시글을\n확인하시겠습니까?",
                    en: "Do you want to\nview this post?",
                    ja: "投稿を\n確認しますか？"
                )
            }

            static func viewWithCans(_ can: Int) -> String {
                pick(
                    ko: "\(can)캔으로 보기",
                    en: "View with \(can) cans",
                    ja: "\(can)canで見る"
                )
            }
        }

        enum LivePayment {
            static var startTimePrefix: String {
                pick(ko: "- 시작 시각 : ", en: "- Start time : ", ja: "- 開始時刻 : ")
            }

            static var currentTimePrefix: String {
                pick(ko: "- 현재 시각 :", en: "- Current time :", ja: "- 現在時刻 :")
            }
        }

        enum LiveRoomPassword {
            static var title: String {
                pick(ko: "비밀번호 입력", en: "Enter password", ja: "パスワード入力")
            }

            static var description: String {
                pick(
                    ko: "비공개 라이브의 입장 비밀번호를\n입력해 주세요.",
                    en: "Please enter the entry password\nfor this private live.",
                    ja: "非公開ライブの入場パスワードを\n入力してください。"
                )
            }

            static var passwordFieldTitle: String {
                pick(ko: "비밀번호", en: "Password", ja: "パスワード")
            }

            static var passwordFieldPlaceholder: String {
                pick(ko: "비밀번호를 입력해 주세요", en: "Please enter your password", ja: "パスワードを入力してください")
            }

            static var enterSuffix: String {
                pick(ko: "으로 입장", en: " to enter", ja: "で入場")
            }

            static var enter: String {
                pick(ko: "입장하기", en: "Enter", ja: "入場する")
            }
        }

        enum MemberProfile {
            static var title: String {
                pick(ko: "프로필", en: "Profile", ja: "プロフィール")
            }

            static var unblock: String {
                pick(ko: "차단 해제", en: "Unblock", ja: "ブロック解除")
            }

            static var reportUser: String {
                pick(ko: "사용자 신고", en: "Report user", ja: "ユーザーを通報")
            }

            static var reportProfile: String {
                pick(ko: "프로필 신고", en: "Report profile", ja: "プロフィールを通報")
            }

            static var invalidRequest: String {
                pick(ko: "잘못된 요청입니다.", en: "Invalid request.", ja: "不正なリクエストです。")
            }
        }
    }

    enum Message {
        static var title: String {
            pick(ko: "메시지", en: "Messages", ja: "メッセージ")
        }

        static var autoDeleteNotice: String {
            pick(
                ko: "※ 보관하지 않은 받은 메시지는 3일 후, 자동 삭제됩니다.",
                en: "※ Unarchived received messages are automatically deleted after 3 days.",
                ja: "※ 保管していない受信メッセージは3日後に自動削除されます。"
            )
        }

        enum Tab {
            static var text: String {
                pick(ko: "문자", en: "Text", ja: "テキスト")
            }

            static var voice: String {
                pick(ko: "음성", en: "Voice", ja: "音声")
            }
        }

        enum FilterTab {
            static var received: String {
                pick(ko: "받은 메시지", en: "Received", ja: "受信")
            }

            static var sent: String {
                pick(ko: "보낸 메시지", en: "Sent", ja: "送信")
            }

            static var archive: String {
                pick(ko: "보관함", en: "Archived", ja: "保管済み")
            }
        }

        enum Text {
            static var emptyState: String {
                pick(
                    ko: "메시지가 없습니다.\n친구들과 소통해보세요!",
                    en: "No messages.\nStart chatting with friends!",
                    ja: "メッセージがありません。\n友だちとコミュニケーションしてみましょう！"
                )
            }

            enum SelectRecipient {
                static var title: String {
                    pick(ko: "받는 사람 검색", en: "Search recipient", ja: "受信者を検索")
                }

                static var nicknamePlaceholder: String {
                    pick(ko: "닉네임을 입력해주세요", en: "Enter a nickname", ja: "ニックネームを入力してください")
                }
            }

            enum Write {
                static var title: String {
                    pick(ko: "새로운 메시지", en: "New message", ja: "新しいメッセージ")
                }

                static var recipientLabel: String {
                    pick(ko: "받는 사람", en: "Recipient", ja: "受信者")
                }
            }

            enum Detail {
                static var receivedTitle: String {
                    pick(ko: "받은 메시지 상세", en: "Received message details", ja: "受信メッセージ詳細")
                }

                static var sentTitle: String {
                    pick(ko: "보낸 메시지 상세", en: "Sent message details", ja: "送信メッセージ詳細")
                }

                static var keptTitle: String {
                    pick(ko: "저장한 메시지 상세", en: "Archived message details", ja: "保管メッセージ詳細")
                }

                static var dateFormat: String {
                    pick(
                        ko: "yyyy년 MM월 dd일 E요일 HH:mm",
                        en: "yyyy-MM-dd E HH:mm",
                        ja: "yyyy年MM月dd日(E) HH:mm"
                    )
                }

                static var reply: String {
                    pick(ko: "답장", en: "Reply", ja: "返信")
                }

                static var keep: String {
                    pick(ko: "보관", en: "Archive", ja: "保管")
                }

                static var alreadyKept: String {
                    pick(ko: "이미 보관된 메시지 입니다", en: "This message is already archived.", ja: "このメッセージはすでに保管済みです。")
                }

                static var deleteFailed: String {
                    pick(
                        ko: "메시지를 삭제하지 못했습니다\n잠시 후 다시 시도해 주세요.",
                        en: "Could not delete the message.\nPlease try again later.",
                        ja: "メッセージを削除できませんでした。\nしばらくしてからもう一度お試しください。"
                    )
                }

                static var deleteSuccess: String {
                    pick(ko: "삭제되었습니다.", en: "Deleted.", ja: "削除されました。")
                }

                static var keepFailed: String {
                    pick(
                        ko: "메시지를 보관하지 못했습니다.\n잠시 후 다시 시도해 주세요.",
                        en: "Could not archive the message.\nPlease try again later.",
                        ja: "メッセージを保管できませんでした。\nしばらくしてからもう一度お試しください。"
                    )
                }

                static var keepSuccess: String {
                    pick(ko: "보관되었습니다.", en: "Archived.", ja: "保管されました。")
                }
            }
        }

        enum Voice {
            enum SavePopup {
                static var title: String {
                    pick(ko: "메시지 보관", en: "Archive message", ja: "メッセージを保管")
                }

                static func description(_ canCount: Int) -> String {
                    pick(
                        ko: "메시지를 보관하는데\n\(canCount)캔이 필요합니다.\n메시지를 보관하시겠습니까?",
                        en: "Archiving this message requires\n\(canCount) cans.\nDo you want to archive this message?",
                        ja: "メッセージを保管するには\n\(canCount)can が必要です。\nこのメッセージを保管しますか？"
                    )
                }

                static var notice: String {
                    pick(
                        ko: "※ 메시지 보관시, 본인이 삭제하기 전까지 영구보관됩니다.",
                        en: "※ Archived messages are kept permanently until you delete them.",
                        ja: "※ 保管したメッセージは、ご自身で削除するまで永久に保管されます。"
                    )
                }
            }

            enum Write {
                static var title: String {
                    pick(ko: "음성메시지", en: "Voice message", ja: "音声メッセージ")
                }

                static var recipientLabel: String {
                    pick(ko: "TO.", en: "TO.", ja: "宛先")
                }

                static var sendButton: String {
                    pick(ko: "메시지 보내기", en: "Send message", ja: "メッセージを送信")
                }

                static var selectRecipient: String {
                    pick(ko: "받는 사람을 선택해 주세요.", en: "Select a recipient.", ja: "受信者を選択してください。")
                }

                static var sendSuccess: String {
                    pick(ko: "메시지 전송이 완료되었습니다.", en: "Your message has been sent.", ja: "メッセージの送信が完了しました。")
                }

                static var sendFailed: String {
                    pick(
                        ko: "음성메시지를 전송하지 못했습니다.\n다시 시도해 주세요.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                        en: "Could not send the voice message.\nPlease try again.\nIf the issue persists, contact customer support.",
                        ja: "音声メッセージを送信できませんでした。\nもう一度お試しください。\n問題が続く場合はカスタマーサポートにお問い合わせください。"
                    )
                }

                static var reRecord: String {
                    pick(ko: "다시 녹음", en: "Record again", ja: "再録音")
                }
            }

            enum Toast {
                static var saveFailed: String {
                    pick(
                        ko: "메시지를 저장하지 못했습니다\n잠시 후 다시 시도해 주세요.",
                        en: "Could not save the message.\nPlease try again later.",
                        ja: "メッセージを保存できませんでした。\nしばらくしてからもう一度お試しください。"
                    )
                }
            }

            enum Sound {
                static var permissionDenied: String {
                    pick(
                        ko: "권한을 허용하지 않으시면 음성메시지 서비스를 이용하실 수 없습니다.",
                        en: "You cannot use voice messages unless microphone permission is allowed.",
                        ja: "権限を許可しない場合、音声メッセージサービスを利用できません。"
                    )
                }

                static var commonError: String {
                    pick(
                        ko: "오류가 발생했습니다. 다시 시도해 주세요.",
                        en: "An error occurred. Please try again.",
                        ja: "エラーが発生しました。もう一度お試しください。"
                    )
                }
            }
        }
    }

    enum Series {
        static var new: String { pick(ko: "신작", en: "New", ja: "新作") }
        static var complete: String { pick(ko: "완결", en: "Completed", ja: "完結") }
        static var popular: String { pick(ko: "인기", en: "Popular", ja: "人気") }
        static var title: String { pick(ko: "시리즈 전체보기", en: "All series", ja: "シリーズ一覧") }
        static var completedSectionTitle: String { pick(ko: "완결 시리즈", en: "Completed series", ja: "完結シリーズ") }
        static var recommendedSectionTitle: String { pick(ko: "추천 시리즈", en: "Recommended series", ja: "おすすめシリーズ") }
        static var byDaySectionTitle: String { pick(ko: "요일별 시리즈", en: "Series by day", ja: "曜日別シリーズ") }
        static var voiceOnOnlyTitle: String { pick(ko: "오직 보이스온에서만", en: "Only on VoiceOn", ja: "VoiceOn限定") }
        static var allEpisodesListen: String { pick(ko: "전체회차 듣기", en: "Listen to all episodes", ja: "全話を聴く") }
        static func allEpisodesTitle(_ seriesTitle: String) -> String { pick(ko: "\(seriesTitle) - 전체회차 듣기", en: "\(seriesTitle) - All episodes", ja: "\(seriesTitle) - 全話を聴く") }
        static var registeredOrder: String { pick(ko: "등록순", en: "Oldest", ja: "登録順") }
        static var point: String { pick(ko: "포인트", en: "Points", ja: "ポイント") }
        static var free: String { pick(ko: "무료", en: "Free", ja: "無料") }
        static var monday: String { pick(ko: "월", en: "Mon", ja: "月") }
        static var tuesday: String { pick(ko: "화", en: "Tue", ja: "火") }
        static var wednesday: String { pick(ko: "수", en: "Wed", ja: "水") }
        static var thursday: String { pick(ko: "목", en: "Thu", ja: "木") }
        static var friday: String { pick(ko: "금", en: "Fri", ja: "金") }
        static var saturday: String { pick(ko: "토", en: "Sat", ja: "土") }
        static var sunday: String { pick(ko: "일", en: "Sun", ja: "日") }
        static var random: String { pick(ko: "랜덤", en: "Random", ja: "ランダム") }
        static var age19Badge: String { pick(ko: "19세", en: "19+", ja: "19+") }
        static func publishing(_ days: String) -> String { pick(ko: "\(days) 연재", en: "\(days)", ja: "\(days)連載") }
        static var totalEpisodes: (Int) -> String = { count in
            pick(ko: "총 \(count)화", en: "Total \(count) episodes", ja: "全\(count)話")
        }

        // 시리즈 전체보기(크리에이터 기준) 타이틀
        static func viewAllByCreator(_ nickname: String) -> String {
            pick(
                ko: "\(nickname) 님의 시리즈 전체보기",
                en: "All series by \(nickname)",
                ja: "\(nickname) さんのシリーズ一覧"
            )
        }
    }

    // 시리즈 상세 화면 관련 문자열 모음
    enum SeriesDetail {
        // 탭
        static var home: String { pick(ko: "홈", en: "Home", ja: "ホーム") }
        static var introduction: String { pick(ko: "작품소개", en: "Introduction", ja: "作品紹介") }

        // 섹션 타이틀
        static var keywords: String { pick(ko: "키워드", en: "Keywords", ja: "キーワード") }
        static var workIntro: String { pick(ko: "작품소개", en: "Introduction", ja: "作品紹介") }
        static var details: String { pick(ko: "상세정보", en: "Details", ja: "詳細情報") }
        static var price: String { pick(ko: "가격", en: "Price", ja: "価格") }

        // 상세 라벨
        static var genre: String { pick(ko: "장르", en: "Genre", ja: "ジャンル") }
        static var ageLimit: String { pick(ko: "연령제한", en: "Age Restriction", ja: "年齢制限") }
        static var writer: String { pick(ko: "작가", en: "Writer", ja: "作家") }
        static var studio: String { pick(ko: "제작사", en: "Produced by", ja: "制作会社") }
        static var schedule: String { pick(ko: "연재", en: "Ongoing", ja: "連載") }
        static var releaseDate: String { pick(ko: "출시일", en: "Release date", ja: "リリース日") }

        // 가격 라벨(명사형)
        static var rentLabel: String { pick(ko: "대여", en: "Rent", ja: "レンタル") }
        static var buyLabel: String { pick(ko: "소장", en: "Buy", ja: "購入") }

        // 값 표기
        static var ageAll: String { pick(ko: "전체연령가", en: "All", ja: "全年齢") }
        static var age19Plus: String { pick(ko: "19세 이상", en: "19+", ja: "R-18") }
        static var random: String { pick(ko: "랜덤", en: "Irregular", ja: "ランダム") }

        // 단위 및 포맷
        static func cansUnit(_ value: Int) -> String {
            pick(ko: "\(value)캔", en: "\(value) cans", ja: "\(value)can")
        }

        static func daysSuffix(_ days: Int) -> String {
            pick(ko: "(\(days)일)", en: "(\(days) day\(days == 1 ? "" : "s"))", ja: "(\(days)日)")
        }

        // 가격 범위 표기: min==max==0 -> 무료, min==max>0 -> N캔, 범위 -> (무료|min) ~ max캔
        static func priceInfo(min: Int, max: Int) -> String {
            if min == max {
                if max == 0 {
                    return CreateContent.free
                } else {
                    return cansUnit(max)
                }
            } else {
                let left = (min == 0) ? CreateContent.free : "\(min)"
                // 범위 구분자는 로케일과 무관하게 시각적 구분자 유지
                return "\(left) ~ \(cansUnit(max))"
            }
        }
    }

    // 시리즈 메인 화면 내부 탭 라벨
    enum SeriesMain {
        // 기존 정의 재사용: 홈은 SeriesDetail.home 과 의미 동일
        static var home: String { SeriesDetail.home }
        static var dayOfWeek: String { pick(ko: "요일별", en: "By day", ja: "曜日別") }
        static var byGenre: String { pick(ko: "장르별", en: "By genre", ja: "ジャンル別") }
    }

    // 콘텐츠 구매/대여 관련 공통 액션 라벨
    enum Purchase {
        static var rent: String { pick(ko: "대여하기", en: "Rent", ja: "レンタルする") }
        static var buy: String { pick(ko: "소장하기", en: "Buy", ja: "購入する") }
        static var purchase: String { pick(ko: "구매하기", en: "Purchase", ja: "購入する") }
    }

    // 마이페이지 > 프로필 수정 내 소셜 링크 섹션
    enum ProfileUpdate {
        // 라벨
        static var instagram: String { pick(ko: "인스타그램", en: "Instagram", ja: "Instagram") }
        static var youtube: String { pick(ko: "유튜브", en: "YouTube", ja: "YouTube") }
        static var kakaoOpenChat: String { pick(ko: "오픈채팅", en: "Open Chat", ja: "オープンチャット") }
        static var fancimm: String { pick(ko: "팬심M", en: "Fancimm", ja: "Fancimm") }
        static var x: String { pick(ko: "X", en: "X", ja: "X") }

        // 플레이스홀더
        static var instagramUrlPlaceholder: String {
            pick(ko: "인스타그램 URL", en: "Instagram URL", ja: "Instagram URL")
        }
        static var youtubeUrlPlaceholder: String {
            pick(ko: "유튜브 URL", en: "YouTube URL", ja: "YouTubeのURL")
        }
        static var kakaoOpenChatUrlPlaceholder: String {
            pick(ko: "오픈채팅 URL", en: "Open Chat URL", ja: "オープンチャット URL")
        }
        static var fancimmUrlPlaceholder: String {
            pick(ko: "팬심M URL", en: "Fancimm URL", ja: "Fancimm URL")
        }
        static var xUrlPlaceholder: String {
            pick(ko: "X URL", en: "X URL", ja: "X URL")
        }

        // 소개글 입력 플레이스홀더
        static var introductionPlaceholder: String {
            pick(ko: "소개글을 입력하세요", en: "Enter your introduction", ja: "自己紹介を入力してください")
        }

        // 프로필/비밀번호 업데이트 관련 토스트/검증 메시지
        static var profileUpdated: String {
            pick(ko: "프로필이 변경되었습니다.", en: "Profile has been updated.", ja: "プロフィールが更新されました。")
        }

        static var passwordCurrentRequired: String {
            pick(ko: "현재 비밀번호를 입력하세요.", en: "Please enter your current password.", ja: "現在のパスワードを入力してください。")
        }
        static var passwordNewRequired: String {
            pick(ko: "변경할 비밀번호를 입력하세요.", en: "Please enter a new password.", ja: "新しいパスワードを入力してください。")
        }
        static var passwordNotMatch: String {
            pick(ko: "비밀번호가 일치하지 않습니다.", en: "Passwords do not match.", ja: "パスワードが一致しません。")
        }
        static var passwordRuleHint: String {
            pick(ko: "영문, 숫자 포함 8자 이상의 비밀번호를 입력해 주세요.", en: "Enter a password of at least 8 characters with letters and numbers.", ja: "英数字を含む8文字以上のパスワードを入力してください。")
        }
        static var passwordUpdated: String {
            pick(ko: "비밀번호가 변경되었습니다.", en: "Password has been changed.", ja: "パスワードが変更されました。")
        }

        static var modifyPasswordTitle: String {
            pick(ko: "비밀번호 변경", en: "Change Password", ja: "パスワード変更")
        }

        static var modifyPasswordGuide: String {
            pick(
                ko: "안전한 비밀번호로 내 내 정보를 보호하세요",
                en: "Protect your information with a secure password.",
                ja: "安全なパスワードで情報を守りましょう。"
            )
        }

        static var currentPasswordTitle: String {
            pick(ko: "현재 비밀번호", en: "Current password", ja: "現在のパスワード")
        }
        static var currentPasswordHint: String {
            pick(ko: "현재 비밀번호를 입력하세요.", en: "Enter your current password.", ja: "現在のパスワードを入力してください。")
        }

        static var newPasswordTitle: String {
            pick(ko: "신규 비밀번호", en: "New password", ja: "新しいパスワード")
        }
        static var newPasswordHint: String {
            pick(
                ko: "신규 비밀번호를 입력해주세요(영문, 숫자 포함 8자 이상)",
                en: "Enter a new password (8+ chars with letters and numbers).",
                ja: "新しいパスワードを入力してください（英数字を含む8文字以上）。"
            )
        }

        static var confirmPasswordTitle: String {
            pick(ko: "신규 비밀번호 확인", en: "Confirm new password", ja: "新しいパスワード確認")
        }
        static var confirmPasswordHint: String {
            pick(ko: "신규 비밀번호를 재입력해주세요", en: "Re-enter the new password.", ja: "新しいパスワードを再入力してください。")
        }

        static var passwordRuleFootnote: String {
            pick(ko: "* 영문, 숫자 포함 8자 이상", en: "* At least 8 characters with letters and numbers", ja: "※ 英数字を含む8文字以上")
        }

        static var changePasswordAction: String {
            pick(ko: "비밀번호 변경하기", en: "Change password", ja: "パスワードを変更する")
        }

        static var nicknameTitle: String {
            pick(ko: "닉네임(최대 12자)", en: "Nickname (max 12)", ja: "ハンドルネーム（最大12文字）")
        }

        static var nicknameHint: String {
            pick(ko: "닉네임", en: "Nickname", ja: "ハンドルネーム")
        }

        static var profileImageUpdateFailed: String {
            pick(
                ko: "프로필 이미지를 업데이트 하지 못했습니다.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                en: "Could not update the profile image.\nIf the problem persists, please contact customer support.",
                ja: "プロフィール画像を更新できませんでした。\n問題が続く場合はカスタマーサポートにお問い合わせください。"
            )
        }
    }

    enum MyPage {
        enum Common {
            static var totalPrefix: String {
                pick(ko: "총", en: "Total", ja: "合計")
            }

            static var personUnit: String {
                pick(ko: "명", en: "people", ja: "人")
            }

            static var countUnit: String {
                pick(ko: "개", en: "items", ja: "件")
            }
        }

        enum Auth {
            static var verified: String {
                pick(ko: "인증완료", en: "Verified", ja: "認証完了")
            }

            static var verifyRequiredBeforeCoupon: String {
                pick(
                    ko: "본인인증 후 등록합니다.",
                    en: "Please complete identity verification before registering.",
                    ja: "本人認証後に登録できます。"
                )
            }

            static var verificationErrorWithSupport: String {
                pick(
                    ko: "본인인증 중 오류가 발생했습니다.\n계속 같은 문제가 발생할 경우 고객센터로 문의 주시기 바랍니다.",
                    en: "An error occurred during identity verification.\nIf the issue persists, contact customer support.",
                    ja: "本人認証中にエラーが発生しました。\n問題が続く場合はカスタマーセンターにお問い合わせください。"
                )
            }
        }

        enum Block {
            static var listTitle: String {
                pick(ko: "차단 리스트", en: "Blocked users", ja: "ブロックリスト")
            }

            static var emptyBlockedUsers: String {
                pick(ko: "차단한 유저가 없습니다.", en: "No blocked users.", ja: "ブロックしたユーザーがいません。")
            }

            static var unblockAction: String {
                pick(ko: "차단해제", en: "Unblock", ja: "ブロック解除")
            }

            static var blockAction: String {
                pick(ko: "차단", en: "Block", ja: "ブロック")
            }
        }

        enum Can {
            static var chargeTitle: String {
                pick(ko: "충전하기", en: "Charge", ja: "チャージ")
            }

            static var chargeAction: String {
                pick(ko: "충전하기", en: "Charge", ja: "チャージする")
            }

            static var chargeShort: String {
                pick(ko: "충전", en: "Charge", ja: "チャージ")
            }

            static var chargeCansAction: String {
                pick(ko: "캔 충전", en: "Charge cans", ja: "canチャージ")
            }

            static var couponRegisterButton: String {
                pick(ko: "쿠폰 등록", en: "Register coupon", ja: "クーポン登録")
            }

            static var statusTitle: String {
                pick(ko: "캔내역", en: "Can history", ja: "can履歴")
            }

            static var paidCan: String {
                pick(ko: "결제 캔", en: "Paid cans", ja: "決済can")
            }

            static var rewardCan: String {
                pick(ko: "리워드 캔", en: "Reward cans", ja: "リワードcan")
            }

            static var chargeHistory: String {
                pick(ko: "충전내역", en: "Charge history", ja: "チャージ履歴")
            }

            static var useHistory: String {
                pick(ko: "사용내역", en: "Usage history", ja: "使用履歴")
            }

            static var localizedUnit: String {
                pick(ko: "캔", en: "cans", ja: "can")
            }

            static var koreanUnitToken: String {
                "캔"
            }

            enum Payment {
                static var title: String {
                    pick(ko: "결제하기", en: "Payment", ja: "決済")
                }

                static var selectMethod: String {
                    pick(ko: "결제 수단 선택", en: "Select payment method", ja: "決済手段を選択")
                }

                static var unifiedMethod: String {
                    pick(ko: "통합 결제", en: "Unified payment", ja: "統合決済")
                }

                static var phoneMethod: String {
                    pick(ko: "휴대폰 결제", en: "Mobile payment", ja: "携帯決済")
                }

                static var cardMethod: String {
                    pick(ko: "카드", en: "Card", ja: "カード")
                }

                static var bankTransferMethod: String {
                    pick(ko: "계좌이체", en: "Bank transfer", ja: "口座振替")
                }

                static var termsAgreement: String {
                    pick(
                        ko: "구매조건 확인 및 결제 진행 동의",
                        en: "Agree to purchase terms and proceed with payment",
                        ja: "購入条件を確認し決済に同意"
                    )
                }

                static var noticeCanExpiry: String {
                    pick(
                        ko: "충전된 캔의 유효기간은 충전 후 5년 입니다.",
                        en: "Charged cans are valid for 5 years after charging.",
                        ja: "チャージしたcanの有効期限はチャージ後5年間です。"
                    )
                }

                static var noticeCancellationPolicy: String {
                    pick(
                        ko: "결제 취소는 결제 후 7일 이내에만 할 수 있습니다.\n단, 캔의 일부를 사용하면 결제 취소를 할 수 없습니다.",
                        en: "Payment cancellation is available only within 7 days after payment.\nHowever, cancellation is not available if part of the cans has been used.",
                        ja: "決済のキャンセルは決済後7日以内のみ可能です。\nただし、canを一部使用した場合はキャンセルできません。"
                    )
                }

                static var noticeEventPointNoRefund: String {
                    pick(
                        ko: "광고성 이벤트 등 회사가 무료로 지급한 포인트는 환불되지 않습니다.",
                        en: "Points provided for free by the company, such as promotional events, are non-refundable.",
                        ja: "広告イベントなど会社が無償で付与したポイントは返金されません。"
                    )
                }

                static var noticeTermsReference: String {
                    pick(
                        ko: "자세한 내용은 보이스온 이용약관에서 확인할 수 있습니다.",
                        en: "For details, please check the VoiceOn Terms of Service.",
                        ja: "詳細はVoiceOn利用規約をご確認ください。"
                    )
                }

                static var amountTitle: String {
                    pick(ko: "결제금액", en: "Payment amount", ja: "決済金額")
                }

                static var payAction: String {
                    pick(ko: "결제하기", en: "Pay", ja: "決済する")
                }

                static var methodRequired: String {
                    pick(ko: "결제수단을 선택해 주세요.", en: "Please select a payment method.", ja: "決済手段を選択してください。")
                }

                static var agreementRequired: String {
                    pick(
                        ko: "결제진행에 동의하셔야 결제가 가능합니다.",
                        en: "You must agree to proceed with payment.",
                        ja: "決済を進めるには同意が必要です。"
                    )
                }

                static var inProgressError: String {
                    pick(ko: "결제 중 오류가 발생했습니다.", en: "An error occurred during payment.", ja: "決済中にエラーが発生しました。")
                }

                static var closeAction: String {
                    pick(ko: "닫기", en: "Close", ja: "閉じる")
                }

                static var exitConfirmTitle: String {
                    pick(ko: "결제를 종료할까요?", en: "Cancel this payment?", ja: "決済を終了しますか？")
                }

                static var continueAction: String {
                    pick(ko: "계속", en: "Continue", ja: "続ける")
                }

                static var exitAction: String {
                    pick(ko: "종료", en: "Exit", ja: "終了")
                }

                static var exitConfirmMessage: String {
                    pick(
                        ko: "진행 중인 결제를 중단하고 이전 화면으로 돌아갑니다.",
                        en: "Stop the ongoing payment and return to the previous screen.",
                        ja: "進行中の決済を中断して前の画面に戻ります。"
                    )
                }

                static var failedWithSupport: String {
                    pick(
                        ko: "결제도중 오류가 발생했습니다.\n고객센터로 문의주시기 바랍니다.",
                        en: "An error occurred during payment.\nPlease contact customer support.",
                        ja: "決済中にエラーが発生しました。\nカスタマーセンターまでお問い合わせください。"
                    )
                }

                static var chargeCompleted: String {
                    pick(ko: "캔이 충전되었습니다", en: "Cans have been charged.", ja: "canがチャージされました。")
                }

                static func wonAmount(_ amount: Int) -> String {
                    pick(ko: "\(amount) 원", en: "₩\(amount)", ja: "₩\(amount)")
                }
            }
        }

        enum Main {
            static var login: String {
                pick(ko: "LOGIN", en: "LOGIN", ja: "ログイン")
            }

            static var viewMyChannel: String {
                pick(ko: "내 채널 보기", en: "View my channel", ja: "自分のチャンネルを見る")
            }

            static var detail: String {
                pick(ko: "자세히", en: "Details", ja: "詳細")
            }

            static var editProfile: String {
                pick(ko: "프로필 수정", en: "Edit profile", ja: "プロフィール編集")
            }

            static var recentlyListenedPrefix: String {
                pick(ko: "최근 들은 ", en: "Recently listened ", ja: "最近聞いた ")
            }
        }

        enum Category {
            static var storage: String {
                pick(ko: "보관함", en: "Library", ja: "保管庫")
            }

            static var blockList: String {
                pick(ko: "차단목록", en: "Blocked list", ja: "ブロックリスト")
            }

            static var couponRegister: String {
                pick(ko: "쿠폰등록", en: "Register coupon", ja: "クーポン登録")
            }

            static var notice: String {
                pick(ko: "공지사항", en: "Notices", ja: "お知らせ")
            }

            static var event: String {
                pick(ko: "이벤트", en: "Events", ja: "イベント")
            }

            static var customerCenter: String {
                pick(ko: "고객센터", en: "Customer center", ja: "カスタマーセンター")
            }
        }

        enum OrderList {
            static var contentStorageTitle: String {
                pick(ko: "콘텐츠 보관함", en: "Content library", ja: "コンテンツ保管庫")
            }

            static var renting: String {
                pick(ko: "대여중", en: "Renting", ja: "レンタル中")
            }

            static var owned: String {
                pick(ko: "소장중", en: "Owned", ja: "所持中")
            }
        }

        enum Point {
            static var historyTitle: String {
                pick(ko: "포인트 내역", en: "Point history", ja: "ポイント履歴")
            }

            static var expirationNotice: String {
                pick(
                    ko: "※ 획득한 포인트는 72시간이 지나면 자동소멸 됩니다.",
                    en: "※ Earned points expire automatically after 72 hours.",
                    ja: "※ 獲得したポイントは72時間後に自動で失効します。"
                )
            }

            static var rewardHistory: String {
                pick(ko: "받은내역", en: "Received", ja: "獲得履歴")
            }

            static var useHistory: String {
                pick(ko: "사용내역", en: "Used", ja: "使用履歴")
            }
        }

        enum Nickname {
            static var paidChangeNotice: String {
                pick(
                    ko: "닉네임 변경으로 인해 피해를 입는 사용자가 지속적으로 발생하여 닉네임 변경을 부득이하게 유료로 전환합니다.",
                    en: "Due to repeated abuse from nickname changes, changing nicknames is now paid.",
                    ja: "ニックネーム変更による被害が継続して発生しているため、ニックネーム変更は有料に変更されました。"
                )
            }

            static var firstFreeNotice: String {
                pick(
                    ko: "최초 1회에 한해서 무료로 변경이 가능하고, 그 이후부터는 유료로 전환됩니다.",
                    en: "You can change your nickname for free only once. After that, it becomes paid.",
                    ja: "初回1回のみ無料で変更でき、それ以降は有料となります。"
                )
            }

            static var duplicateCheckAction: String {
                pick(ko: "중복확인", en: "Check duplicate", ja: "重複確認")
            }

            static var changeAction: String {
                pick(ko: "닉네임 변경하기", en: "Change nickname", ja: "ニックネームを変更する")
            }

            static func changeActionWithCans(_ cans: Int) -> String {
                pick(
                    ko: "\(cans)캔으로 닉네임 변경하기",
                    en: "Change nickname with \(cans) cans",
                    ja: "\(cans)canでニックネームを変更する"
                )
            }

            static var available: String {
                pick(ko: "사용가능한 닉네임 입니다.", en: "This nickname is available.", ja: "使用可能なニックネームです。")
            }

            static var empty: String {
                pick(ko: "닉네임을 입력하세요.", en: "Please enter a nickname.", ja: "ニックネームを入力してください。")
            }

            static var changed: String {
                pick(ko: "닉네임이 변경되었습니다.", en: "Nickname has been changed.", ja: "ニックネームが変更されました。")
            }

            static var duplicateCheckRequired: String {
                pick(ko: "닉네임 중복체크를 해주세요.", en: "Please check nickname duplication.", ja: "ニックネームの重複確認をしてください。")
            }
        }

        enum Profile {
            static var changeNicknameAction: String {
                pick(ko: "닉네임 변경", en: "Change nickname", ja: "ニックネーム変更")
            }

            static var genderTitle: String {
                pick(ko: "성별", en: "Gender", ja: "性別")
            }

            static var female: String {
                pick(ko: "여자", en: "Female", ja: "女性")
            }

            static var male: String {
                pick(ko: "남자", en: "Male", ja: "男性")
            }

            static var notPublic: String {
                pick(ko: "공개 안 함", en: "Private", ja: "非公開")
            }

            static var interestsTitle: String {
                pick(ko: "관심사", en: "Interests", ja: "関心事")
            }

            static var selectInterestsAction: String {
                pick(ko: "관심사 선택", en: "Select interests", ja: "関心事を選択")
            }

            static var introductionTitle: String {
                pick(ko: "소개글", en: "Introduction", ja: "自己紹介")
            }

            static var saveAction: String {
                pick(ko: "저장하기", en: "Save", ja: "保存する")
            }
        }

        enum ReservationStatus {
            static var title: String {
                pick(ko: "예약현황", en: "Reservation status", ja: "予約状況")
            }

            static var live: String {
                pick(ko: "라이브", en: "Live", ja: "ライブ")
            }
        }

        enum Reservation {
            static func cansUnit(_ cans: Int) -> String {
                pick(ko: "\(cans)캔", en: "\(cans) cans", ja: "\(cans)can")
            }

            enum LiveStatus {
                static var title: String {
                    pick(ko: "라이브 예약 현황", en: "Live reservation status", ja: "ライブ予約状況")
                }

                static var emptyMessage: String {
                    pick(ko: "예약한 라이브가 없습니다.", en: "No reserved live sessions.", ja: "予約したライブがありません。")
                }

                static var cancelUnavailable: String {
                    pick(ko: "예약 취소 불가", en: "Cancellation unavailable", ja: "予約キャンセル不可")
                }

                static var cancelAction: String {
                    pick(ko: "예약\n취소", en: "Cancel\nreservation", ja: "予約\nキャンセル")
                }

                static var free: String {
                    pick(ko: "무료", en: "Free", ja: "無料")
                }
            }

            enum Cancel {
                static var title: String {
                    pick(ko: "예약취소", en: "Cancel reservation", ja: "予約キャンセル")
                }

                static var completedTitle: String {
                    pick(ko: "예약취소 확인", en: "Cancellation complete", ja: "予約キャンセル確認")
                }

                static var completedMessage: String {
                    pick(ko: "예약취소가 완료되었습니다.", en: "Reservation cancellation is complete.", ja: "予約キャンセルが完了しました。")
                }

                static func refundedCanMessage(_ cans: Int) -> String {
                    pick(
                        ko: "결제한 \(cans)캔이\n환불처리 되었습니다.",
                        en: "Your paid \(cans) cans\nhave been refunded.",
                        ja: "決済した\(cans)canは\n返金処理されました。"
                    )
                }

                static var reserveAnotherLiveAction: String {
                    pick(ko: "다른 라이브 예약하기", en: "Reserve another live", ja: "別のライブを予約する")
                }

                static var checkCanHistoryAction: String {
                    pick(ko: "캔내역 확인하기", en: "Check can history", ja: "can履歴を確認する")
                }

                static var confirmQuestion: String {
                    pick(ko: "예약을 취소하시겠습니까?", en: "Do you want to cancel this reservation?", ja: "予約をキャンセルしますか？")
                }

                static var reasonDescription: String {
                    pick(
                        ko: "예약취소 이유를 선택해주세요. 서비스 개선에 중요한 자료로 활용하겠습니다.",
                        en: "Please select a reason for cancellation. It will be used to improve our service.",
                        ja: "予約キャンセル理由を選択してください。サービス改善の重要な資料として活用します。"
                    )
                }

                static var reasonPlaceholder: String {
                    pick(ko: "입력해주세요", en: "Please enter", ja: "入力してください")
                }

                static var notice: String {
                    pick(
                        ko: "취소요청시, 차감했던 캔은 환불처리 됩니다. 수다방 참여인원 제한에 따라 재예약이 불가할 수 있습니다.",
                        en: "When you request cancellation, deducted cans will be refunded. Re-reservation may be unavailable depending on participant limits.",
                        ja: "キャンセル申請時、差し引かれたcanは返金されます。参加人数制限により再予約できない場合があります。"
                    )
                }

                static var requestCancelAction: String {
                    pick(ko: "예약취소", en: "Request cancellation", ja: "予約キャンセル")
                }

                static var invalidReservationInfo: String {
                    pick(ko: "잘못된 예약정보 입니다.", en: "Invalid reservation information.", ja: "無効な予約情報です。")
                }

                static var reasonRequired: String {
                    pick(ko: "취소이유를 선택해주세요.", en: "Please select a cancellation reason.", ja: "キャンセル理由を選択してください。")
                }

                static var reasonPersonalSchedule: String {
                    pick(ko: "중요한 개인일정이 생겨서", en: "I have an important personal schedule", ja: "重要な個人的予定ができたため")
                }

                static var reasonOtherLive: String {
                    pick(ko: "다른 라이브에 참여하고 싶어서", en: "I want to join another live", ja: "他のライブに参加したいため")
                }

                static var reasonUncomfortableParticipant: String {
                    pick(ko: "라이브 참여자 중 불편한 사람이 있어서", en: "There is an uncomfortable participant", ja: "参加者の中に不快な人がいるため")
                }

                static var reasonPriceBurden: String {
                    pick(ko: "참여비용이 부담되서", en: "Participation cost is burdensome", ja: "参加費が負担になるため")
                }

                static var reasonEtc: String {
                    pick(ko: "기타", en: "Other", ja: "その他")
                }
            }
        }

        enum ServiceCenter {
            static var buttonTitle: String {
                pick(ko: "보이스온 고객센터", en: "VoiceOn customer center", ja: "VoiceOnカスタマーセンター")
            }

            static var talkInquiry: String {
                pick(ko: "TALK 문의", en: "Talk inquiry", ja: "TALK お問い合わせ")
            }

            static var faqTitle: String {
                pick(ko: "자주 묻는 질문", en: "Frequently asked questions", ja: "よくある質問")
            }

            static var questionPrefix: String {
                pick(ko: "Q", en: "Q", ja: "Q")
            }

            static var answerPrefix: String {
                pick(ko: "A", en: "A", ja: "A")
            }
        }
    }

    enum User {
        static var emailTitle: String {
            pick(ko: "이메일", en: "Email", ja: "メール")
        }

        static var emailPlaceholder: String {
            pick(ko: "이메일", en: "Email", ja: "メール")
        }

        static var passwordTitle: String {
            pick(ko: "비밀번호", en: "Password", ja: "パスワード")
        }

        static var passwordPlaceholder: String {
            pick(ko: "비밀번호", en: "Password", ja: "パスワード")
        }

        static var showPassword: String {
            pick(ko: "비밀번호 표시", en: "Show password", ja: "パスワードを表示")
        }

        static var emailRequired: String {
            pick(ko: "이메일을 입력해 주세요.", en: "Please enter your email.", ja: "メールアドレスを入力してください。")
        }

        static var emailInvalid: String {
            pick(ko: "올바른 이메일을 입력하세요", en: "Enter a valid email address.", ja: "正しいメールアドレスを入力してください。")
        }

        static var passwordRequired: String {
            pick(ko: "비밀번호를 입력해 주세요.", en: "Please enter your password.", ja: "パスワードを入力してください。")
        }

        static var blockUserAction: String {
            pick(ko: "사용자 차단하기", en: "Block user", ja: "ユーザーをブロック")
        }

        static var unblockUserAction: String {
            pick(ko: "사용자 차단해제", en: "Unblock user", ja: "ユーザーのブロックを解除")
        }

        static var reportUserAction: String {
            pick(ko: "사용자 신고하기", en: "Report user", ja: "ユーザーを通報")
        }

        static var reportProfileAction: String {
            pick(ko: "프로필 신고하기", en: "Report profile", ja: "プロフィールを通報")
        }
    }

    enum SignUp {
        static var title: String {
            pick(ko: "회원가입", en: "Sign up", ja: "会員登録")
        }

        static var terms: String {
            pick(ko: "이용약관", en: "Terms of service", ja: "利用規約")
        }

        static var privacyPolicy: String {
            pick(ko: "개인정보수집 및 이용동의", en: "Consent to collect and use personal information", ja: "個人情報の収集および利用への同意")
        }

        static var required: String {
            pick(ko: "(필수)", en: "(Required)", ja: "(必須)")
        }

        static var submit: String {
            pick(ko: "회원가입", en: "Sign up", ja: "会員登録")
        }

        static var agreementRequired: String {
            pick(ko: "약관에 동의하셔야 회원가입이 가능합니다.", en: "You must agree to the terms to sign up.", ja: "利用規約に同意する必要があります。")
        }
    }

    enum FindPassword {
        static var title: String {
            pick(ko: "비밀번호 재설정", en: "Reset password", ja: "パスワード再設定")
        }

        static var description1: String {
            pick(ko: "회원가입한 이메일 주소로\n임시 비밀번호를 보내드립니다.", en: "We will send a temporary password to the email address you used to sign up.", ja: "登録したメールアドレスに仮パスワードを送信します。")
        }

        static var description2: String {
            pick(ko: "임시 비밀번호로 로그인 후\n마이페이지 > 프로필 설정에서\n비밀번호를 변경하고 이용하세요.", en: "Log in with the temporary password, then change it in My Page > Profile Settings.", ja: "仮パスワードでログイン後、マイページ > プロフィール設定でパスワードを変更してください。")
        }

        static var emailPlaceholder: String {
            pick(ko: "이메일을 입력하세요", en: "Enter your email", ja: "メールアドレスを入力してください")
        }

        static var submit: String {
            pick(ko: "임시 비밀번호 받기", en: "Get temporary password", ja: "仮パスワードを受け取る")
        }

        static var contactSupport: String {
            pick(ko: "고객센터로 문의하기", en: "Contact support", ja: "カスタマーセンターに問い合わせる")
        }

        static var emailRequired: String {
            pick(ko: "이메일을 입력하세요.", en: "Please enter your email.", ja: "メールアドレスを入力してください。")
        }

        static var successMessage: String {
            pick(ko: "임시 비밀번호가 입력하신 이메일로 발송되었습니다.\n이메일을 확인해 주세요.", en: "A temporary password has been sent to your email.\nPlease check your inbox.", ja: "仮パスワードを入力したメールアドレスに送信しました。\nメールをご確認ください。")
        }
    }

    enum Login {
        static var title: String {
            pick(ko: "로그인", en: "Log in", ja: "ログイン")
        }

        static var login: String {
            pick(ko: "로그인", en: "Log in", ja: "ログイン")
        }

        static var forgotPassword: String {
            pick(ko: "비밀번호를 잊으셨나요?", en: "Forgot your password?", ja: "パスワードを忘れましたか？")
        }

        static var signUpPrompt: String {
            pick(ko: "보이스온 회원이 아닌가요? 지금 가입하세요.", en: "Not a VoiceOn member? Sign up now.", ja: "VoiceOnの会員ではありませんか？今すぐ登録してください。")
        }

        static var appleAuthorizationFailed: String {
            pick(ko: "애플 로그인 정보를 가져오지 못했습니다.", en: "Failed to retrieve Apple sign-in information.", ja: "Appleログイン情報を取得できませんでした。")
        }

        static var appleTokenMissing: String {
            pick(ko: "애플 인증 토큰을 가져오지 못했습니다.", en: "Failed to retrieve Apple identity token.", ja: "Apple認証トークンを取得できませんでした。")
        }

        static var appleRetry: String {
            pick(ko: "다시 시도해 주세요.", en: "Please try again.", ja: "もう一度お試しください。")
        }

        static var appleSignInFailed: String {
            pick(ko: "애플 로그인에 실패했습니다.\n다시 시도해 주세요.", en: "Apple sign-in failed.\nPlease try again.", ja: "Appleログインに失敗しました。\nもう一度お試しください。")
        }

        enum Google {
            static var openFailed: String {
                pick(
                    ko: "구글 로그인 화면을 열 수 없습니다.\n다시 시도해 주세요.",
                    en: "Unable to open Google sign-in.\nPlease try again.",
                    ja: "Googleログイン画面を開けません。\nもう一度お試しください。"
                )
            }

            static var configMissing: String {
                pick(
                    ko: "구글 로그인 설정을 확인할 수 없습니다.\n다시 시도해 주세요.",
                    en: "Unable to find Google sign-in settings.\nPlease try again.",
                    ja: "Googleログイン設定を確認できません。\nもう一度お試しください。"
                )
            }

            static var signInFailed: String {
                pick(
                    ko: "구글 로그인에 실패했습니다.\n다시 시도해 주세요.",
                    en: "Google sign-in failed.\nPlease try again.",
                    ja: "Googleログインに失敗しました。\nもう一度お試しください。"
                )
            }

            static var tokenMissing: String {
                pick(
                    ko: "구글 인증 토큰을 가져오지 못했습니다.",
                    en: "Failed to retrieve Google token.",
                    ja: "Google認証トークンを取得できませんでした。"
                )
            }
        }

        enum Kakao {
            static var signInFailed: String {
                pick(
                    ko: "카카오 로그인에 실패했습니다.\n다시 시도해 주세요.",
                    en: "Kakao sign-in failed.\nPlease try again.",
                    ja: "Kakaoログインに失敗しました。\nもう一度お試しください。"
                )
            }

            static var tokenMissing: String {
                pick(
                    ko: "카카오 인증 토큰을 가져오지 못했습니다.",
                    en: "Failed to retrieve Kakao token.",
                    ja: "Kakao認証トークンを取得できませんでした。"
                )
            }
        }

        enum Line {
            static var openFailed: String {
                pick(
                    ko: "라인 로그인 화면을 열 수 없습니다.\n다시 시도해 주세요.",
                    en: "Unable to open LINE sign-in.\nPlease try again.",
                    ja: "LINEログイン画面を開けません。\nもう一度お試しください。"
                )
            }

            static var signInFailed: String {
                pick(
                    ko: "라인 로그인에 실패했습니다.\n다시 시도해 주세요.",
                    en: "LINE sign-in failed.\nPlease try again.",
                    ja: "LINEログインに失敗しました。\nもう一度お試しください。"
                )
            }

            static var tokenMissing: String {
                pick(
                    ko: "라인 인증 토큰을 가져오지 못했습니다.",
                    en: "Failed to retrieve LINE token.",
                    ja: "LINE認証トークンを取得できませんでした。"
                )
            }
        }
    }

    // 문자 메시지(Text Message) 관련 문자열
    enum TextMessage {
        // 전송 버튼 라벨
        static var send: String {
            pick(ko: "메시지 보내기", en: "Send", ja: "メッセージを送る")
        }

        // 입력창 플레이스홀더
        static var placeholder: String {
            pick(ko: "내용을 입력해 주세요.", en: "Please enter your message.", ja: "内容を入力してください。")
        }

        // 수신자 입력 플레이스홀더
        static var recipientPlaceholder: String {
            pick(ko: "받는 사람", en: "To.", ja: "受信者")
        }

        // 수신자 미선택 오류
        static var selectRecipient: String {
            pick(ko: "받는 사람을 선택해 주세요.", en: "Select a recipient.", ja: "受信者を選択してください。")
        }

        // 전송 성공 토스트/팝업 문구
        static var sendSuccess: String {
            pick(ko: "메시지 전송이 완료되었습니다.", en: "Your message has been sent.", ja: "メッセージの送信が完了しました。")
        }

        enum Validation {
            // 최소 글자 수 안내
            static func minLength(_ count: Int) -> String {
                pick(
                    ko: "\(count)글자 이상 입력해 주세요.",
                    en: "Please enter at least \(count) characters.",
                    ja: "\(count)文字以上で入力してください。"
                )
            }
        }
    }
}

// MARK: - 내부 헬퍼
@inline(__always)
private func pick(ko: String, en: String, ja: String) -> String {
    switch LanguageHeaderProvider.current {
    case "ko": return ko
    case "ja": return ja
    default:    return en
    }
}

/*
 사용 예시 (ViewModel, Service 등 Text 이외 컨텍스트):

 // ViewModel 내부
 let title = I18n.Common.all

 // View 내부(Text 대신 다른 UI 요소 라벨 등)
 let menuLabel = I18n.Common.settings

 주의: 기존에 Text("...")와 같은 String Catalog 사용부는 그대로 유지합니다.
*/