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 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件まで固定できます。このコンテンツを固定すると最も古い固定コンテンツが置き換えられます。"
            )
        }
    }
    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 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 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 SignOut {
            // 탈퇴 사유 목록 (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桁）を入力してください。") }
    }

    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 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 chatDeleteTitle: String { pick(ko: "채팅 삭제", en: "Delete chat", ja: "チャット削除") }
    }

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

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

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

        static var reservationCanceled: String {
            pick(
                ko: "예약이 취소되었습니다.",
                en: "Reservation has been canceled.",
                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 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)を削除しますか？"
            )
        }
    }

    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 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 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 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 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 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 사용부는 그대로 유지합니다.
*/