/* eslint-disable prettier/prettier */
export default {
  setup: {
    connect: {
      title: 'Blocklet 서버 설정',
      scan: '다음 방법을 사용하여 이 서버의 소유자가 되세요',
      confirm: '당신의 DID 지갑에서 이 작업을 확인하세요',
      success: '귀하의 계정은 이 서버에 연결되어 있습니다'
    },
    keyPair: {
      title: 'KeyPair 유도',
      scan: '이 앱에 대한 키 쌍을 생성하기 위해 DID 지갑을 연결하세요',
      confirm: 'DID 지갑에서이 작업을 검토하십시오',
      success: '귀하의 키 쌍은 안전하게 저장됩니다'
    },
    verify: {
      title: '소유권 자격 증명이 필요합니다',
      scan: '소유권 자격증을 제공하기 위해 DID 지갑을 연결하세요',
      confirm: '귀하의 DID 지갑에서이 작업을 검토하십시오',
      success: '귀하의 계정은 이 서버에 연결되어 있습니다'
    },
    accept: {
      title: '서버 소유권 인증서 수락',
      scan: '소유권 자격증을 제공하기 위해 DID 지갑을 연결하세요',
      confirm: 'DID 지갑에서이 작업을 검토하십시오',
      success: '귀하의 계정은이 서버에 연결되어 있습니다'
    },
    title: 'Blocklet 서버 설정',
    steps: {
      eula: '최종 사용자 라이선스 동의서',
      eulaFooter: 'EULA 약관을 읽고 동의했습니다',
      connect: '소유자 DID 지갑 연결하기',
      verify: '소유권 확인',
      basicSettings: '기본 설정',
      launchApp: '앱 실행하기',
      complete: '완료'
    },
    congratulation: '축하합니다! Blocklet 서버가 안전하게 준비되어 사용할 준비가 되었습니다.',
    redirectButton: '대시보드로 이동해주세요!'
  },
  login: {
    loginTo: '연결하기',
    description: '서버 소유자 및 승인된 회원만이 대시보드에 접근할 수 있습니다',
    switchDid: {
      title: '계정 전환',
      scan: '다음 방법으로 계정을 추가하십시오',
      confirm: 'DID 지갑에서 스위치를 확인하세요',
      success: '성공적으로 전환되었습니다'
    },
    switchSpecifiedDid: {
      title: '계정 전환',
      scan: '다음 동작을 완료하기 위해 DID 를 {did} 로 변경해야합니다',
      confirm: 'DID 지갑에서 스위치를 확인하세요',
      success: '성공적으로 전환되었습니다'
    },
    connect: {
      title: '연결',
      scan: '서버 소유주와 승인된 멤버만 대시보드에 접근할 수 있습니다',
      confirm: '계정에서 확인하세요',
      success: '연결이 성공적으로 되었습니다'
    },
    verify: {
      title: '접근 확인',
      scan: '소유자 또는 관리자 여권을 제시하기 위해 DID 지갑을 연결하세요',
      confirm: '계정에서 확인',
      success: '접근이 확인되었습니다',
      abort: '접근 인증이 중단되었습니다',
      description: '이 작업을 수행하려면 {roles} 여권을 제공해야 하며, 1시간 동안 활동이 없으면 다시 확인 요청을 받게 됩니다.',
      descriptionForDestroy: '안전을 보장하기 위해 {roles} 여권을 제공하여 이 위험한 작업을 수행해야 합니다.'
    },
    login: '연결',
    termsOfUse: '이용 약관',
    agreeTermsOfUse: '해당 사항을 읽고 동의합니다'
  },
  acceptServer: {
    title: '소유권 NFT로 서버를 요청',
    tooltip: '서버 소유권 NFT를 받은 경우,이 링크를통해 소유자 여권을 요청할 수 있습니다.'
  },
  exchangePassport: {
    title: 'NFT로 여권 교환하기',
    success: '여권을 성공적으로 교환하고 여권으로 로그인했습니다.',
    login: '로그인',
    dialog: {
      title: 'NFT로 여권 받기',
      scan: 'DID 월렛을 연결하여 NFT를 제출하고 여권을 받으세요',
      confirm: 'DID 지갑에서 NFT를 선택하세요',
      success: '여권이 성공적으로 교환되었습니다'
    },
    tooltip1: '만약 당신이 컬렉션의 NFT를 소유하고 있다면,',
    tooltip2: '이 링크로 여권을 교환할 수 있습니다.'
  },
  payablePassport: {
    title: '지불로 여권 구매',
    tooltip: '여권을 소지하고 있지 않은 경우 이 링크로 여권을 구매할 수 있습니다.'
  },
  sidebar: {
    dashboard: '대시보드',
    blocklets: 'Blocklets',
    console: '콘솔',
    settings: '설정'
  },
  system: {
    total: '총',
    used: '사용함',
    free: '자유',
    cores: '코어 수',
    instances: '인스턴스 수'
  },
  common: {
    invalid: '잘못된',
    about: '약',
    access: '접근',
    accessKey: '액세스 키',
    action: '액션',
    actions: '행동',
    add: '추가해주세요',
    address: '주소',
    afterTime: '{time} 후',
    allow: '허용하다',
    alreadyExist: '이미 존재합니다',
    approve: '승인',
    approved: '승인',
    appUrl: '앱 링크',
    auditLogs: '감사 추적',
    author: '저자',
    avatar: '아바타',
    back: '뒤로',
    basic: '기본',
    basicInfo: '기본 정보',
    profile: '프로필',
    bind: '바인드하기',
    blocklet: '블록렛',
    blocklets: 'Blocklets',
    blockletsStorage: '블록릿 저장소',
    cacheStorage: '캐시 저장소',
    cancel: '취소',
    certificate: '인증서',
    category: '로그 주제',
    click: '복사하려면 클릭',
    close: '닫기',
    selectAll: '모두 선택',
    unselectAll: '모두 선택 해제',
    collapseAll: '모두 접기',
    community: '커뮤니티 URL',
    complete: '완료',
    componentBasicInfo: '구성 요소 기본 정보',
    components: 'Blocklets',
    config: '구성하다',
    configuration: '구성',
    appearance: '모양',
    configNavigation: '네비게이션',
    configSuccess: '구성이 성공적으로 완료되었습니다',
    confirm: '확인',
    connect: '연결',
    console: '콘솔',
    continue: '계속',
    continueWith: '계속하기',
    copiedTip: '복사되었습니다',
    copyAndClose: '복사 및 닫기',
    copyTip: '복사를 클릭하세요',
    coreStorage: '코어 스토리지',
    cpu: 'CPU',
    create: '생성하다',
    createSuccess: '액세스 키 생성하기',
    created: '작성일',
    createdAt: '생성일',
    createdBy: '만든이',
    dAddress: '분산 식별자 (DID)',
    dataStorage: '로컬 디스크의 저장소',
    delConfirm: '삭제',
    delConfirmDescription: '{data} 삭제를 확인하시겠습니까?',
    delete: '삭제',
    dependents: '부양 가족',
    description: '설명',
    detail: '세부사항',
    did: 'DID',
    disk: '디스크',
    diskInfo: '디스크 정보',
    docker: 'Docker입니다',
    documentation: '문서',
    domain: '도메인',
    downgradeTo: '다운그레이드',
    download: '다운로드하기',
    downloading: '다운로드 중',
    edit: '편집',
    email: '이메일',
    phone: '전화기',
    empty: '빈',
    emptyData: '결과를 찾을 수 없습니다',
    enable: '사용 설정',
    engine: '엔진',
    env: '환경',
    environment: '환경',
    expandAll: '모두 펼치기',
    expired: '만료됨',
    expires: '만료',
    export: '내보내기',
    externalIp: '외부 IP',
    failed: '실패',
    filter: '로그 필터',
    fingerprint: '지문',
    finish: '끝내기',
    forbid: '금지',
    free: '자유함',
    general: '장군',
    gitpod: 'Gitpod입니다',
    goEULA: '클릭하여 "최종 사용자 라이선스 계약"을(를) 확인하세요',
    group: '그룹',
    image: 'IS 이미지',
    install: '설치',
    installed: '설치 완료',
    installedAt: '설치된 위치',
    installSuccess: '성공적으로 설치되었습니다',
    installing: '설치 중',
    internalIp: '내부 IP',
    introduction: '소개',
    invite: '초대',
    inviting: '초대',
    ip: 'IP',
    isPublic: '공공의',
    issue: '문제',
    issuer: '발행인',
    item: '아이템',
    joined: '참여함',
    key: '키',
    lastPublishedAt: '게시된 날짜',
    launcher: '런처 정보',
    leavePageTip: '페이지를 떠나시겠습니까?',
    link: '링크',
    loading: '로딩 중',
    log: '로그 보기',
    logStorage: '로그 스토리지',
    login: '로그인',
    logo: '로고',
    logout: '로그아웃',
    logs: '로그',
    manageTeam: '팀 관리하기',
    marketplace: '마켓플레이스',
    member: '회원',
    members: '멤버',
    memory: '기억',
    meta: '메타 데이터',
    analytics: '분석',
    runtime: '런타임',
    traffic: '교통',
    more: '더',
    mountPoint: '마운트 포인트',
    name: '이름',
    next: '다음',
    no: '아니요',
    noData: '표시할 레코드가 없습니다',
    notice: '이것을 읽지 않으면 예상치 못한 나쁜 일이 발생할 것입니다!',
    noticeTitle: '공지',
    notification: '알림',
    open: '열기',
    management: '매니지먼트',
    os: '운영 체제',
    overview: '개요',
    owner: '소유자',
    page404: '404 페이지',
    passport: '여권',
    permission: '허가',
    port: '포트',
    pre: '이전의',
    preferences: '환선',
    preview: '미리보기',
    protected: '보호됨',
    protocol: '프로토콜',
    purchase: '구매',
    readMore: '더',
    redirect: '리디렉션',
    redirectCode: '리다이렉트 코드',
    redirectPermanently: '영구 리디렉션',
    redirectTemporary: '임시 리디렉션',
    redirectUrl: '리디렉션 URL',
    rewrite: '재작성하기',
    release: '릴리스',
    rewriteUrl: 'URL을 다시 작성하세요',
    reject: '거부',
    reload: '새로고침',
    remark: '비고',
    remove: '삭제',
    removeSuccess: '성공적으로 제거되었습니다',
    renew: '갱신하다',
    reportIssue: '문제 신고하기',
    required: '필요한',
    requiredErrorText: '{name} 이 필요합니다',
    resource: '자원',
    restart: '재시작',
    restore: '복원',
    retry: '다시 시도해주세요',
    revoke: '취소하다',
    role: '역할',
    running: '달리기',
    runtimeInfo: '실행 정보',
    save: '저장',
    saveChanges: '변경 사항 저장',
    saveSuccess: '저장되었습니다',
    scheduleFailed: '일정 실패',
    scheduleSuccess: '성공적으로 예약되었습니다',
    scope: '범위',
    screenshot: '화면 캡쳐',
    search: '검색',
    security: '보안',
    serverDid: '서버 DID',
    serverVersion: '서버 버전',
    setting: '설정',
    start: '시작',
    status: '상태',
    stop: '중지',
    storage: '저장소',
    backup: '백업',
    store: '상점',
    succeeded: '성공했습니다',
    subscription: '구독',
    support: '지원 URL 또는 이메일',
    switch: '스위치',
    team: '팀',
    the: '이',
    timeAgo: '{time} 전',
    title: '제목',
    type: '유형',
    unavailable: '사용할 수 없음',
    update: '업데이트',
    updateAvailable: '새로운 버전 {version} 을 사용할 수 있습니다',
    updatedAt: '{time}에 업데이트됨',
    updatedBy: '업데이트된 사람',
    upgrade: '업그레이드',
    upgradeTo: '업그레이드하세요',
    upgrading: '업그레이드',
    uptime: '가동 시간',
    url: 'URL',
    valid: '유효한',
    value: '값',
    version: '버전',
    visit: '방문하다',
    waiting: '기다리는 중',
    webhook: '통합',
    yes: '네',
    invalidParam: '잘못된 매개변수',
    launch: '시작',
    price: '가격',
    redirecting: '리다이렉트 중',
    error: '에러',
    reminder: '알림',
    normal: '보통',
    gateway: '게이트웨이',
    verifyNFT: 'NFT 확인하기',
    errorMessage: '에러 메세지:',
    slugifyHint: '실제 마운트 포인트는 {value}입니다',
    strategy: '전략',
    auto: '자동차',
    manual: '사용 설명서',
    progress: '진행 중',
    startTime: '시작 시간',
    endTime: '종료 시간',
    timeoutError: '시간 초과 오류',
    tags: '태그',
    connectToStore: '상점에 연결하기',
    uploaded: '업로드되었습니다',
    upload: '업로드',
    blockletStudio: '스튜디오',
    visitStore: '가게 방문하기',
    reconnect: '재연결',
    change: '변경',
    disconnect: '연결 끊기',
    sourceApp: '앱에 속함',
    visitTarget: '{name}를 방문하다',
    upgradeServer: '서버 업그레이드',
    display: '표시',
    requiredInputPlaceholder: '입력해주세요 {name}',
    refresh: '새로고침',
    moveUp: '위쪽으로 이동',
    moveDown: '아래로 이동',
    enabled: '활성화됨',
    disabled: '사용 중지',
    homepage: '홈페이지',
    buy: '구매',
    view: '보기',
    homepageTip: '홈페이지 또는 라이브 데모 URL',
    repository: '저장소',
    expand: '확장',
    collapse: '접기',
    all: '모두',
    notificationRecords: '알림',
    unrecordedUser: '기록되지 않은 이름',
    unrecordedRole: '기록되지 않은 역할',
    auditLogsSearch: '작업 또는 내용으로 검색',
    optional: '선택 사항',
    bugOrConnectDomain: '기존 도메인을 구매하거나 연결합니다',
    bugOrConnectDomainTip: '도메인 이름은 인터넷에서 웹사이트의 고유 주소입니다. DID Names 또는 다른 도메인 등록기관에서 새 도메인을 구매하거나, 이미 소유하고 있는 기존 도메인을 구성할 수 있습니다.',
    connectExistingDomain: '기존 도메인 연결',
    domains: '도메인',
    didDomains: 'DID 도메인',
    manualDomains: '내 도메인',
    didDomainsDescription: '다음 도메인은 DID:Names 서비스에서 자동으로 관리됩니다.',
    systemDomains: '시스템 할당',
    systemDomainsDescription: '다음 도메인은 기본적으로 자동으로 할당됩니다. 접근할 수 있지만, 운영 환경용으로는 의도되지 않았으며 고객과 공유해서는 안 됩니다. 이러한 도메인은 주로 개발 목적으로 사용됩니다.',
    manualDomainsDescription: '다음 도메인은 도메인 제공업체에서 관리하며, 여기로 수동으로 설정되었습니다.',
    fileCount: '파일 수',
    fileSize: '파일 크기',
    time: '시간',
    less: '적게',
    timeInfo: '시간',
    operator: '운영자',
    inviter: '초대자',
    clear: '지우기',
    ok: 'OK',
    minutes: '분',
    hours: '시간',
    hour: '시간',
    days: '일',
    day: '일',
    weeks: '주',
    months: '개월',
    custom: '사용자 정의',
    environments: '환경',
    sites: '사이트',
    active: '활성',
    backupTime: '백업 시간',
    lastUsedAt: '마지막 사용 시각',
    expiredAt: '만료일',
    createdVia: '통해',
    neverExpired: '절대',
    baseInfo: '기본 정보',
    otherInfo: '기타 정보',
    lightMode: '라이트 모드',
    darkMode: '다크 모드',
    advancedConfig: '고급',
    document: '문서',
    mcpServers: 'MCP 서버',
    generate: '생성',
    copy: '복사',
    copied: '복사됨',
    orgs: '조직',
    userSessions: '사용자 세션'
  },
  blocklet: {
    external: '외부의',
    notFound: '이 서버에서 블록이 발견되지 않았습니다. 아마도 삭제되었을 수 있습니다',
    installFromMarket: '새로운 블록릿 설치하기',
    installFromUrl: 'URL에서 설치하기',
    installFromCreate: '블록렛 생성하기',
    installFromDiskBackup: '이 서버에서 복원',
    installedAt: '설치 위치:',
    internal: '내부',
    startedAt: '시작되었습니다',
    stoppedAt: '중지된',
    urlEmptyTip: '접근할 수 없는 URL',
    goToAddRule: '추가에 이동하기',
    services: '노출된 서비스',
    upstreamPort: '상류 포트',
    noService: '서비스 없음',
    appId: 'App DID',
    appPid: '영구적인 DID',
    alsoKnownAs: 'AKA',
    skSource: '소유자 지갑',
    reloadSuccess: 'Blocklet이 성공적으로 다시로드되었습니다',
    statusTip: 'Blocklet은 {status} 입니다',
    initialUptime: '1미터 미만',
    dashboard: '블록릿 대시보드',
    noComponent: '응용 프로그램에 구성 요소가 없으므로 시작할 수 없습니다',
    fromUrl: {
      title: '블록릿 설치',
      label: '블록릿 메타 URL',
      description: 'URL은 Blocklet의 메타 파일을 가리켜야 합니다. 로컬 파일을 참조해야 하는 경우 file:// 접두사를 추가해주세요. 예: file:///Users/foo/blocklet.json.',
      confirm: '설치',
      step0: '입력 URL',
      step1: '메타 정보 확인',
      existTipPrefix: '같은 DID를 가진 Blocklet이 이미 존재합니다. 버전은 {version}입니다',
      existTipSuffix: '고급 버전을 설치해주세요.'
    },
    action: {
      stopDescription: '블록릿을 중지하면 해당 공개 인터페이스에 액세스할 수 없으며, 이는 최종 사용자의 실패를 일으킬 수 있습니다',
      stopComponentDescription: '구성 요소를 중지하면 해당 공용 인터페이스에 접근할 수 없으며, 이는 최종 사용자의 실패를 야기할 수 있습니다',
      confirmStop: '네, 그만해주세요',
      cancelDownloadDescription: '{name}의 다운로드를 취소하시겠습니까?',
      removeApplicationDescription: '이 응용 프로그램을 제거하면이 응용 프로그램에 의해 생성된 코드 및 데이터가 지워지며, 백업이 없는 경우 복원할 수 없습니다',
      removeApplicationAfterBackup: '애플리케이션을 백업하고 제거하세요. 필요한 경우 이 서버에서 애플리케이션을 복원할 수 있습니다',
      removeApplicationComplete: '이 애플리케이션의 코드와 데이터를 모두 제거하세요',
      removeComponentDescription: '컴포넌트를 삭제하면 해당 컴포넌트가 생성한 코드와 데이터가 손실되며, 백업이 없는 경우 복구할 수 없습니다',
      removeComponentKeepData: '이 구성 요소의 데이터를 유지하되 코드는 제거하세요',
      removeComponentComplete: '이 구성 요소의 코드와 데이터를 모두 제거하세요',
      confirmRemove: '네, 제거합니다',
      confirmComponentRemove: '네, 삭제하세요',
      upgradeDescription: '블록을 업그레이드하면 일시적으로 사용할 수 없습니다. 계속하시겠습니까?',
      confirmUpgrade: '네, 업그레이드하세요',
      confirmRestart: '네, 다시 시작해주세요',
      restartDescription: '블록의 재시작은 일시적으로 중단되며 구성 변경으로 인해 시작되지 않을 수 있습니다'
    },
    dev: {
      modeTip: 'Blocklet 서버를 디버그 모드로 전환해주세요'
    },
    index: {
      tableTitle: '블록렛 관리하기',
      noBlocklet: '이 Blocklet 서버에서는 블록렛을 찾을 수 없습니다. 마켓 플레이스에서 블록렛을 설치하여 시작하십시오.'
    },
    config: {
      name: '앱 이름',
      description: '앱 설명',
      logoSquare: '앱 로고',
      logoRect: '웹사이트 로고',
      logoRectDesc: '사용 위치: 웹사이트 헤더와 푸터, 설정되지 않은 경우 앱 로고로 대체됩니다',
      logoFavicon: 'Favicon',
      logoFaviconDesc: '사용 위치: 브라우저 주소 표시줄 및 탭, 설정되지 않은 경우 앱 로고로 대체',
      clusterSize: '클러스터 모드에서 이 블록렛을 실행할 때 인스턴스 수',
      copyrightOwner: '저작권자',
      copyrightYear: '저작권 년',
      deletable: {
        name: '삭제 보호',
        enable: '현재로서는이 blocklet을 삭제할 수 없습니다',
        disable: '이 블록은 현재 삭제할 수 있습니다'
      },
      walletType: {
        name: '지갑 유형',
        description: 'Blocklet 인스턴스 지갑 유형, 파생된 DID가 변경될 것입니다'
      },
      languages: '지원되는 언어',
      selectLanguagesTip: '제거하고 다시 추가하여 순서를 조정하세요',
      languagesSearch: '국가의 현지 이름, 영문 이름 또는 ISO 코드로 검색하세요...',
      passportColor: '여권 색깔',
      appUrl: '앱 URL',
      access: {
        title: '누가 접근할 수 있나요?',
        description: '애플리케이션에 대한 접근 제어 방식을 선택하세요.',
        useDefault: '기본값 사용',
        defaultDescription: '애플리케이션의 기본 구성을 사용하세요',
        whoCanAccess: {
          all: {
            title: '모두에게 공개',
            description: '여권 없이 누구나 접근할 수 있는 세계에 개방되어 있습니다'
          },
          owner: {
            title: '소유자 전용 접근',
            description: '이 애플리케이션에 접근하려면 소유자 여권을 제출해야 합니다'
          },
          invited: {
            title: '초대된 사람만 접근 가능',
            description: '초대된 회원만 접근할 수 있습니다.'
          }
        },
        publicToStore: '상점에서 공개',
        publicInstanceTip: '이 블록렛의 접근 주소는 스토어에 표시됩니다 (기부금 수령을 위한 DID와 함께)',
        updatedTip: '접근 제어가 수정되었습니다'
      },
      changedTip: '구성이 업데이트되었습니다. Blocklet을 다시 시작하세요',
      missingRequired: '블록렛을 시작하기 위해 필요한 설정이 누락되었습니다',
      gotoFix: '고칠 곳으로 가세요',
      environment: {
        key: '구성 키',
        value: '구성 값',
        keyValueRequired: '구성 키와 값은 지정되어야 합니다',
        invalidKey: '구성 키는 BLOCKLET_ 또는 COMPONENT_로 시작해서는 안 됩니다',
        deleteForbidden: '이 구성은 필수이며 삭제되면 안 됩니다',
        tip: 'BWA_ 로 시작하는 구성에는 민감한 정보를 포함시키지 마십시오. 브라우저로 전송될 것이기 때문입니다'
      },
      dangerZone: '위험 지역',
      sharedToAllComponents: '모든 구성 요소와 공유될 예정입니다',
      session: {
        ttl: '{day} 일 동안 이 사이트에서 활동이 없는 경우 사용자에게 다시 로그인하라는 안내가 표시됩니다',
        day: '{day}일',
        days: '{day} 일',
        period: '세션 유효 기간',
        profile: '사용자 프로필 요구 사항',
        cacheTtl: '사용자 세션 데이터의 캐시 기간 (초 단위)',
        fullNameEnabled: '로그인 시 사용자 이름 요청 (기본 설정으로 활성화)',
        avatarEnabled: '로그인시 사용자 아바타 요청 (기본으로 활성화)',
        emailEnabled: '로그인시 사용자 이메일 요청',
        emailRequireVerified: '사용자 이메일이 로그인하기 전에 확인되어야 함',
        emailRequireUnique: '모든 사용자 전체에서 사용자 이메일이 고유해야 함',
        phoneEnabled: '로그인시 사용자 전화번호 요청 (아직 지원되지 않음)',
        phoneRequireVerified: '로그인 전에 사용자 전화번호를 확인해야 합니다',
        phoneRequireUnique: '모든 사용자를 통틀어 사용자 전화번호가 고유해야 함',
        emailTrustOauthProviders: '이메일 확인 상태를 위한 OAuth 제공 업체 신뢰',
        enableDomainBlackList: '이메일 도메인 블랙리스트 활성화(목록된 이메일 도메인 거부)',
        enableDomainWhiteList: '이메일 도메인 화이트리스트 활성화 (목록에 포함된 이메일 도메인만 로그인 허용)',
        addDomain: '목록을 가져 오는 소스 추가 (일반 텍스트 형식, 한 번에 도메인)',
        enableBlacklist: '로그인 token 및 리프레시 token 폐기 활성화',
        experimentalSettings: '실험 설정'
      },
      clearCache: {
        name: '캐시 관리',
        purpose: '라우터 및 블록렛 서비스에 캐시된 파일 관리하기',
        title: '캐시를 지우시겠습니까?',
        action: '캐시 지우기',
        success: '{count}개의 캐시 엔트리를 성공적으로 지웠습니다',
        description: '라우터와 블록렛 서비스에서 캐시 파일을 지우시겠습니까? 이 작업은 단기간 내에 약간의 성능 저하를 일으킬 수 있습니다.'
      },
      tenantMode: {
        name: '멀티 테넌트 모드',
        multiple: '이 블록렛은 여러 테넌트 모드에서 실행되며 각 테넌트마다 데이터가 격리되어야 합니다',
        single: '이 블록렛은 단일 테넌트 모드에서 실행되며, 모든 데이터가 공유됩니다'
      },
      splashPortrait: '스플래시 이미지',
      splashLandscape: '스플래시 랜드스케이프',
      splashPortraitDesc: 'Blocklet 실행 시 표시됩니다. PNG 또는 JPG 형식 권장, 세로는 9:16, 가로는 16:9 종횡비 (최대 5MB)',
      rotateSessionKey: {
        name: '세션 소금 회전',
        purpose: '세션 솔트는 세션 토큰의 보안을 강화하는 데 사용되는 임의의 값입니다. 버튼을 클릭하여 세션 솔트를 수동으로 회전하면 로그인 토큰 손상 위험을 줄이는 데 도움이 됩니다.',
        title: '세션 소금 회전을 확인합니까?',
        action: '소금을 회전',
        success: '세션 소금이 성공적으로 회전되었습니다',
        description: '세션 솔트를 회전하시겠습니까? 이 작업은 기존의 모든 로그인 토큰을 무효화하고 사용자에게 다시 로그인하도록 강제합니다 (본인의 로그인 토큰 포함).'
      },
      ogImage: 'Open Graph 배경',
      ogImageDesc: '사용처: 소셜 미디어 공유 배경',
      migrate: {
        button: 'DID Wallet으로 마이그레이션',
        title: 'DID 변경 확인',
        description: '서버 관리형 지갑으로 시작하는 경우 애플리케이션 DID를 자신의 지갑으로 변경할 수 있습니다.',
        confirm: '애플리케이션 DID를 변경하시겠습니까? 이 작업은 기존 세션을 모두 무효화하고 사용자(본인 포함)가 다시 로그인하도록 합니다.'
      },
      vault: {
        name: 'Vault DID',
        title: 'Vault 설정',
        desc: '이 Blocklet 이 관리하는 자금에 추가적인 보안 계층을 추가하기 위해 vault 를 사용하세요.',
        tip: '계속하려면 vault 주소를 입력하세요. 사용하기 전에 vault 주소의 소유권을 증명해야 합니다.',
        address: 'Vault 주소',
        verified: 'Vault 가 확인되었습니다',
        current: '현재 Vault',
        error: {
          invalid: 'Vault 주소는 유효한 DID 이어야 합니다',
          holder: 'Vault 주소는 블록체인에서 유효한 토큰 보유자여야 합니다. 토큰/자산/팩토리/스테이크 주소는 지원되지 않습니다.',
          duplicate: '이 vault 주소는 이미 사용되었습니다. 다른 주소를 사용하십시오',
          appDid: '애플리케이션 DID를 vault 주소로 사용할 수 없습니다. 다른 주소를 사용하십시오'
        },
        role: '역할 유형',
        firstSeen: '처음 본',
        lastSeen: '마지막 확인',
        migratedFrom: '에서 마이그레이션됨',
        migratedTo: '이동됨',
        commit: {
          title: 'Vault 소유권 확인',
          scan: '다음 방법을 사용하여 볼트 소유권을 확인하십시오',
          confirm: 'DID Wallet 사용 확인',
          success: 'Vault 가 성공적으로 구성되었습니다'
        },
        approve: {
          title: 'Vault 변경 승인',
          byOwner: '변경 사항을 승인하려면 Blocklet 소유자와 서명하십시오',
          byLast: '변경을 승인하려면 마지막 볼트로 서명합니다',
          confirm: 'DID Wallet을 사용하여 확인',
          success: 'Vault 변경이 승인되었습니다'
        }
      },
      changeImageTip: '팁: 사진을 변경하려면 미리보기 사진을 클릭하여 변경하십시오.',
      baseInfo: '기본 정보',
      baseInfoDesc: '여기서 웹사이트의 기본 정보를 설정할 수 있습니다.',
      logoSettings: '시각 정보',
      logoSettingsDesc: '독창적인 브랜드 이미지를 구축하고 다양한 시나리오에서 웹사이트의 인지도와 시각적 매력을 향상시킵니다.',
      languagesDesc: '사용 위치: 방문자 언어 선택',
      nameDesc: '사용 위치: DID Connect 헤더, 브라우저 탭, 웹사이트 푸터, SEO 메타데이터 및 OpenGraph 메타데이터',
      descriptionDesc: '사용 위치: SEO 메타데이터 및 OpenGraph 메타데이터',
      logoSquareDesc: '사용 위치: 사용자 인증 대화 상자 바닥글 및 <b>DID Wallet</b> 앱 목록',
      logoDesc: '권장 크기: {width} * {height} 픽셀',
      splashDesc: 'ArcSphere 앱 실행 화면 (설정된 경우 <b>ArcSphere</b>에 표시됨)\n\n세로 모드:\n비율: 9:16\n\n가로 모드:\n비율: 16:9',
      copyrightDesc: '사용 위치: 웹사이트 푸터',
      appUrlDesc: '사용 위치: 사이트맵 및 소셜 공유',
      advanced: '고급 설정'
    },
    overview: {
      source: '원본',
      deployedFrom: '배포된 위치',
      accessControl: '접근 제어',
      viewInStore: '상점에서 보기'
    },
    diskInfo: {
      empty: '디스크 정보가 현재 사용할 수 없습니다!',
      appDir: '앱 디렉토리',
      dataDir: '데이터 디렉토리',
      logDir: '로그 디렉토리',
      cacheDir: '캐시 디렉토리'
    },
    runtimeInfo: {
      noRunning: '블록렛이 실행 중일 때 런타임 정보를 사용할 수 있습니다!',
      memoryUsage: '메모리 사용량',
      cpuUsage: 'CPU 사용량',
      uptime: '업타임',
      port: '포트',
      processId: '프로세스 ID'
    },
    dist: {
      downloadLink: '다운로드 링크',
      verify: '확인하다'
    },
    status: {
      added: '추가됨',
      waiting: '기다리는 중',
      downloading: '다운로드 중',
      extracting: '추출중',
      installing: '설치 중',
      upgrading: '업그레이드',
      installed: '설치 완료',
      created: '생성된',
      starting: '시작',
      running: '달리기',
      stopping: '중지',
      stopped: '정지됨',
      error: '오류',
      deleting: '삭제 중',
      corrupted: '손상된',
      purchasing: '구매를 기다리는 중',
      purchased: '구매한',
      verifying: '구매 확인 중',
      resource: '자원'
    },
    list: {
      download: '다운로드',
      star: '별',
      searchPlaceholder: '블록렛 이름 또는 DID로 검색'
    },
    component: {
      container: '글로벌 설정',
      showContainer: '전역 구성 표시',
      didSpaceConfig: 'DID 공간 구성',
      didSpaceConfigTip: 'DID Spaces에 애플리케이션 데이터를 저장하기 위해 다음 권한 부여 프로세스를 완료하세요',
      didSpaceConnected: '스토리지에 인가된 내용: {endpoint}',
      checkUpdateTitle: '업데이트 확인',
      updateTitle: '컴포넌트 업데이트',
      noUpdate: '업데이트할 컴포넌트가 없습니다',
      add: '컴포넌트 추가하기',
      selectComponent: '블록렛 선택',
      selectRegistry: '블록렛 스토어를 선택하세요',
      selectRegistryTip: '더 많은 구성 요소를 보려면 Blocklet 스토어를 전환할 수 있습니다',
      selectInstance: '인스턴스 선택',
      selectInstanceTip: '기존 인스턴스를 선택하거나 새 인스턴스를 생성할 수 있습니다. 기존 인스턴스는 이전에 저장된 구성 및 데이터를 사용합니다',
      newInstance: '새로운 인스턴스 생성',
      noComponent: '구성 요소가 없습니다',
      mountPoint: '마운트 포인트는 무엇인가요?',
      mountPointTip: "'/my-prefix'로 마운트 포인트를 설정하면 해당 마운트 포인트로 시작하는 모든 요청이 선택된 구성 요소로 라우팅됩니다.",
      delete: '구성 요소 삭제',
      deleteDescription: '이 구성요소는 삭제 후에 접속할 수 없습니다. 삭제하시겠습니까?',
      purchase: '결제가 필요합니다',
      tip: {
        stopBlocklet: '먼저 Blocklet 실행을 중지하세요',
        requiredBy: '구성 요소는 {name}이(가) 필요합니다'
      },
      choose: '선택',
      addWithName: '{name}에 블록렛 추가하기',
      installingCanCloseWindowTip: '백그라운드에서 구성 요소를 설치하는 중이니 이 창을 안전하게 닫아주세요',
      installSuccessTip: '축하합니다, 구성 요소가 성공적으로 설치되었습니다!',
      missDownloadTokenTip: '유효한 다운로드 토큰이 없어 유료 구성 요소를 추가할 수 없습니다',
      purchaseComponentSecondCheckTip: '계속하려면 블록체인 구매 NFT를 제시하세요',
      installComponentError: '구성 요소 설치 중에 오류가 발생했습니다. 다시 시도해주세요',
      downloadComponentError: '구성 요소를 다운로드하는 중에 오류가 발생했습니다. 다시 시도해주세요',
      addComponentTip: {
        introduction: '구성 요소 추가 마법사에 오신 것을 환영합니다',
        isPurchase: '<b>{name}</b>을(를) 구성 요소로 사용하기 전에 NFT를 확인해야 합니다',
        belowInformation: '아래는 구성 요소에 대한 정보입니다:',
        verifyNFT: 'NFT 검증 방법을 선택해주세요',
        config: '컴포넌트의 구성을 입력하세요',
        environment: '구성 요소 환경을 입력해주세요',
        fromUrl: 'URL에서 Blocklet 추가하기',
        fromUpload: '업로드에서 Blocklet 추가',
        uploadFailed: '업로드 실패',
        allowedFileTypes: '업로드 가능한 파일 형식: {types}'
      },
      addNext: '{name} 추가하기',
      upgradeNext: '{name} 업그레이드',
      setting: '설정',
      noDependencies: '{name}는 의존성이 없습니다',
      relatedComponents: '관련된 블록',
      required: '필요한',
      installed: '설치됨',
      installingTip: '컴포넌트를 설치하는 중입니다. 기다려 주세요...',
      upgrade: '업그레이드',
      upgradeAvailable: '업데이트 가능',
      needBuy: '구매해야 합니다',
      isOfficial: '공식 인증'
    },
    router: {
      urlPath: 'URL 경로',
      noRunning: '블록렛이 현재 시작되지 않았습니다. 다음 주소를 통해 액세스할 수 없습니다!',
      securitySetting: '보안 설정',
      checkUrlAccessible: '주소의 접근성을 확인하세요',
      urlInaccessible: '네트워크 문제로 인해 주소에 일시적으로 액세스할 수 없습니다',
      noAccessibleUrl: '접근 가능한 URL이 없습니다',
      domainLockTooltip: '시스템에서 생성한 도메인은 편집할 수 없습니다.',
      urlLockTooltip: '시스템에서 생성한 URL 경로는 편집할 수 없습니다.',
      showAllDomains: '모든 도메인 표시',
      showAllDIDs: '모든 DID 보이기',
      currentDomainTip: '현재 페이지에 이 도메인을 통해 접근 중입니다'
    },
    export: {
      title: 'Blocklet 내보내기',
      name: '번들 이름',
      nameTip: '나의-blocklet-name',
      result: '다음은 무엇입니까?',
      exportSource: '소스 내보내기',
      success: '블록렛이 성공적으로 내보내졌습니다',
      resultTipStart: '함께',
      resultTipEnd: '몇 분 안에 이 블록렛을 빌드하고 배포할 수 있습니다',
      uploadedComponentTip: '직접 업로드한 구성요소는 내보낼 수 없습니다.'
    },
    migrate: {
      title: '애플리케이션 이전',
      scan: '이 애플리케이션에서 키 쌍을 생성하기 위해 DID 지갑을 연결하세요',
      confirm: 'DID 지갑에서이 작업을 확인하십시오',
      success: '애플리케이션이 성공적으로 이전되었습니다. {sec}초 후에 페이지가 새로고침됩니다',
      intro: {
        l1: '여기를 클릭하세요',
        l2: '애플리케이션을 새 버전으로 이전하기 위한 작업 (이전이 완료될 때까지 변경 사항이 비활성화됨)',
        l3: '신청서 DID는 DID 지갑에서 완전히 제어될 것입니다.',
        l4: '2. 응용 프로그램 데이터가 이전될 것이며, 추가적인 변경 사항은 필요하지 않습니다.',
        l5: '3. 새로운 애플리케이션 구조를 사용하면 구성요소 변경 시 더 유연하게 대응할 수 있습니다.',
        l6: '4. 컴포넌트의 새 버전이 출시되기 전에 구성 요소 마운트 포인트를 변경하지 마세요.'
      },
      tip: {
        duplicate: '중복된 구성요소 {name}을 찾아서 불필요한 구성요소를 삭제하고 다시 마이그레이션하세요',
        running: '이전하기 전에 블록릿을 중지하세요'
      }
    },
    error: {
      isRunning: 'Blocklet가 실행 중입니다. 먼저 중지해주세요',
      isInProgress: 'Blocklet이 진행 중입니다. 완료까지 기다려주세요'
    },
    publish: {
      createResource: '리소스 생성하기',
      addResource: '릴리즈 추가',
      productTitle: '제품',
      versionTitle: '버전 관리',
      imgTitle: '사진',
      resourceTitle: '콘텐츠',
      blockletEmptyTip: '여기에 Blocklets 는 없습니다',
      createBlockletTip: '이 애플리케이션에서 기존의 리소스, 구성 요소 및 설정을 사용하여 새로운 블록렛을 생성할 수 있습니다',
      createBlocklet: '새로운 블록렛',
      componentNotRunning: '{name} 블록릿이 실행되고 있지 않습니다, 먼저 시작하십시오',
      releaseEmptyTip: '여기에는 출시 정보가 없습니다',
      createReleaseTip: '다른 사람들이 사용할 수 있도록 블록릿의 릴리스와 릴리스 노트 및 자원을 생성할 수 있습니다',
      createRelease: '릴리스 생성',
      deleteReleaseTip: '삭제 후에는 복구할 수 없는 릴리스입니다',
      createBlockletDid: 'DID 지갑에서 작성',
      createReleaseSuccess: '릴리스가 성공적으로 생성되었습니다',
      saveDraftSuccess: '드래프트가 성공적으로 저장되었습니다',
      connect: {
        title: 'Blocklet DID 생성하기',
        scan: '다음 방법을 사용하여 Blocklet DID를 생성합니다',
        confirm: 'DID 지갑을 사용하여 확인하세요',
        success: 'Blocklet DID가 생성되었습니다. 계속 작업해주세요.'
      },
      saveDraft: '임시 보관',
      releaseNote: '릴리즈 노트',
      errorTip: {
        noDid: 'Blocklet DID가 필요합니다',
        noTitle: 'Blocklet 제목은 필수입니다',
        noVersion: 'Blocklet 버전이 필요합니다',
        noDescription: 'Blocklet 설명이 필요합니다',
        noNote: '릴리즈 노트가 필요합니다',
        inValidVersion: '잘못된 블록릿 버전',
        noResource: '블록렛에 포함할 업로드 리소스를 선택하십시오',
        noFirstDid: '먼저 Blocklet DID를 생성하세요',
        invalidUrl: '유효한 URL을 입력하세요',
        invalidUrlOrEmail: '유효한 URL 또는 이메일을 입력하세요'
      },
      packTip: '현재 블록렛은 직접 애플리케이션으로 설치할 수 있습니다. 컴포넌트와 애플리케이션 구성은 자동으로 블록렛에 포함됩니다',
      resourceChangedWarning: '리소스를 수정하였으니 시간 안에 저장하세요',
      installResourceTip: '설치 URL:',
      installResourceTip2: '추가 팁을 보려면 {name}을(를) 방문하세요',
      installResourceHelp: '도움말 문서',
      componentIncluded: '포함됨',
      componentForceRequired: '필수',
      download: '{name} 다운로드하기',
      delete: '{name} 삭제',
      copyInstallUrl: '설치 URL 복사하기',
      install: '{name}을(를) 설치하세요',
      publishToStoreSuccess: 'Store에 성공적으로 발행된 Blocklet',
      connectStoreSuccess: '블록렛 스토어가 성공적으로 연결되었습니다',
      uploadToStoreSuccess: '블록렛이 성공적으로 스토어에 업로드되었습니다. 스토어에서 게시해야 합니다',
      viewLastRelease: '최신 릴리스 보기',
      reconnectStoreTip: '재연결 후에는 새로운 개발자가 연결됩니다. 재연결 하시겠습니까?',
      deleteProject: {
        title: '{name}을 삭제하세요',
        scan: '다음 방법으로 {name}을 삭제하세요',
        confirm: 'DID 지갑을 사용하여 확인하세요',
        success: 'Blocklet 프로젝트가 삭제되었습니다. 작업을 계속하세요',
        tip1: 'Blocklet 프로젝트는 삭제 후에 복구할 수 없습니다',
        tip2: '삭제된 블록릿에 새로운 버전을 게시할 수 없으므로, 블록릿은 더 이상 스토어에서 업데이트되지 않습니다.',
        tip3: '블록을 삭제하더라도 스토어에서 현재 공개된 버전에는 영향을 주지 않습니다.',
        description: 'Blocklet을 삭제한 후 다음과 같은 문제가 발생합니다. 삭제하시겠습니까?'
      },
      resourceTip: '현재, 리소스 블록릿으로서, 직접 상점에서 설치할 수 없습니다.',
      whyCantSeeInStore: '현재 Blocklet을 스토어에 게시할 수 있으며 전 세계에서 사용할 수 있습니다',
      whyCantSeeResourceBlockletInStore: '현재 Blocklet을 스토어에 게시할 수 있으며 전 세계에서 사용할 수 있습니다. Blocklets는 기본적으로 스토어 목록 페이지에 숨겨져 있습니다',
      tenantScope: '임차인',
      blockletStudio: 'Blocklet Studio',
      allComponentsNotRunning: 'Blocklets가 실행되고 있지 않습니다. 먼저 시작해주세요.',
      resourceEmptyTip: '사용 가능한 자원이 없습니다',
      steps: {
        resources: '현재 Blocklet과 관련된 리소스를 선택해주세요. 이 리소스들은 Blocklet과 함께 설치될 것입니다.',
        blocklets: '관련된 블록렛을 선택하세요.',
        version: '릴리스 버전과 변경 로그를 설정하세요.',
        introduction: '명확한 소개는 당신의 블록릿을 효과적으로 강조할 수 있습니다. 마크다운 구문을 사용하여 작성하고 미리 보기할 수 있습니다.',
        branding: 'Blocklet의 기본 정보를 설명하세요. 이 정보는 상점에 사용자에게 제공됩니다.'
      },
      branding: '브랜딩',
      brandingHelp: '블록릿에 대한 자세한 정보가 스토어에 표시됩니다',
      resourceSelect: '블록릿에서 리소스 선택',
      resourceUpload: '디스크에서 리소스를 업로드하세요 (아카이브에 index.html이 필요합니다)',
      deleteStoreTip: '{name}을(를) 연결 스토어 목록에서 제거하시겠습니까?',
      disconnectStoreTip: '연결이 끊어지면 Blocklet이 스토어에서 제거됩니다. 연결을 끊으시겠습니까?',
      connectOrUpload: '연결하거나 업로드',
      developerInfo: '개발자 정보',
      autoUploadTip: '릴리스 후 블록릿을 자동으로 스토어에 업로드합니다',
      possibleSameStoreTip: '가능한 경우 업로드하기 전에 종속성 블록렛을 동일한 블록렛 스토어에 해결하려고 시도하십시오',
      needProjectId: '먼저 프로젝트를 만들어주세요',
      projectSettings: '프로젝트 설정',
      noStoreSelected: '계속하려면 기존 상점 중 하나를 선택하거나 새로운 상점을 추가하십시오',
      installToThisServer: '이 서버에 설치',
      forceResourceBlocklet: '리소스 기반 블록렛으로 정의되는 힘',
      resourceDocker: 'Docker 에서 Blocklet 빌드',
      resourceSelectTitle: '자원',
      resourceUploadTitle: '업로드',
      resourceDockerTitle: 'Docker',
      resourceDockerInputTip: 'docker run 명령어를 입력해 주세요',
      docker: {
        pleaseInputDockerCommand: 'docker run 명령어를 입력하세요',
        volumeTip: '볼륨은 $BLOCKLET_DATA_DIR 또는 $BLOCKLET_APP_DIR 로 시작해야 합니다',
        volumeTip2: '볼륨에는 ".." 를 포함할 수 없습니다',
        noAllowTheArg: 'docker run 명령에서 해당 인수를 사용할 수 없습니다',
        needCustomInput: 'Blocklet 설치 시 값을 설정하십시오',
        dockerParams: 'Docker 매개변수',
        dockerCommand: 'Docker 명령',
        dockerImageName: 'Docker 이미지 이름',
        addItem: 'Docker 실행 매개변수 추가',
        envKey: '환경 변수 키',
        publishTips: '최종 외부 포트는 blocklet 에 의해 자동으로 할당됩니다',
        volumeTips: '볼륨은 $BLOCKLET_DATA_DIR 또는 $BLOCKLET_APP_DIR 로 시작해야 합니다',
        modifyParam: 'Docker 실행 매개변수 수정',
        modifyEnv: '환경 변수 수정',
        paramDetail: '매개변수 세부사항',
        description: '설명',
        secure: '안전한',
        shared: '공유',
        required: '필수',
        prefix: '접두사',
        path: '경로',
        name: '이름',
        portType: '포트 유형',
        dockerImageNameError: 'Docker 이미지 이름에는 공백을 포함할 수 없습니다',
        autoGenerated: '자동 생성',
        dockerCMDError: 'Docker CMD는 간단한 문자만 지원합니다',
        proxyBehavior: '프록시 동작',
        serviceProxy: '서비스',
        directProxy: '직접',
        nextTab: '명령 분석'
      },
      storeRule: {
        maxImageCount: '스토어에서는 최대 {max}개의 스크린샷을 허용합니다.',
        minImageCount: '스토어는 최소 {min} {unit}이 필요합니다.',
        minImageSize: ' {name} 스크린샷 이미지 크기는 최소 {width}x{height}여야 합니다.',
        logoFormat: '로고 이미지 형식은 [{format}]만 지원합니다',
        warning: '경고',
        screenshot: '스크린샷',
        screenshots: '스크린샷',
        first: '첫 번째',
        second: '2번째',
        third: '3번째'
      },
      store: 'Blocklet 스토어',
      endpoint: {
        tab: '원격 Blocklet',
        uploadToEndpoint: '현재 Blocklet을 지정된 Blocklet에 업로드할 수 있습니다.',
        addEndpoint: 'Blocklet 엔드포인트 추가',
        urlEmpty: '엔드포인트 URL은 비워둘 수 없습니다',
        addFailed: 'Blocklet 엔드포인트 추가 실패: ',
        deleteEndpoint: 'Blocklet 엔드포인트 삭제',
        deleteDesc: 'Blocklet 엔드포인트 {name} 삭제를 확인하시겠습니까?<br/><span style="color: {color}">*이 Blocklet 엔드포인트를 제거한 후에는, 이 Blocklet 엔드포인트에서 설치된 앱은 다시 추가하지 않는 한 업데이트할 수 없습니다.</span>',
        confirmDesc: '{name}을 입력하여 삭제하십시오',
        visitEndpoint: 'Blocklet 방문',
        disconnectEndpointTip: '{url} 연결을 끊으시겠습니까? 연결을 끊으면 Blocklet이 이 엔드포인트에 업로드되지 않습니다.',
        deleteFailed: 'Blocklet 엔드포인트 삭제 실패',
        publishToEndpointSuccess: 'Blocklet 이 Endpoint에 성공적으로 게시되었습니다',
        uploadToEndpointSuccess: 'Blocklet 이 Endpoint에 성공적으로 업로드되었습니다'
      },
      autoPublishErrorTip: '자동 게시가 {storeName}에 실패했습니다: {error}',
      singleton: '단일 인스턴스만',
      singletonTip: '싱글턴 모드가 활성화되면 애플리케이션은 동시에 여러 인스턴스를 실행할 수 없습니다. 앱이 싱글턴 모드를 사용하기 때문에 업데이트나 재시작에는 블루-그린 배포를 사용할 수 없습니다.'
    },
    titleValidationError: '제목 길이는 3 자에서 20 자 사이여야 합니다',
    descriptionValidationError: '설명 길이는 3에서 80 자여야합니다.',
    whyNeedAppPid: '애플리케이션이 마이그레이션된 경우 영구 DID는 이 Blocklet이 처음 설치되었을 때 생성된 DID입니다.',
    usingDocker: '이 블록 렛은 도커를 사용하여 실행됩니다',
    gotoVisitError: 'Blocklet URL에 접근할 수 없습니다, 나중에 다시 시도해 주세요',
    usingIsolation: '이 Blocklet은 네트워크 격리하여 실행됩니다',
    dockerImage: 'Docker 지원',
    mountPoint: {
      description1: '이 변경으로 이전 마운트 지점이 포함된 URL이 손상될 수 있으며, 이는 다음과 같은 결과로 이어질 수 있습니다:',
      case1: '이 앱 내 Blocklets 간의 리소스 참조가 손상되었습니다',
      case2: 'URL이 잘못되었습니다. 공개적으로 공유한 경우',
      description2: '기존 마운트 지점에서 새 마운트 지점으로 리다이렉션을 설정하여 발생 가능한 중단 변경을 최소화할 수 있습니다.'
    },
    skSourceMigratedTip: '이 앱은 서버 관리 지갑으로 시작하여 더 나은 보안을 위해 DID Wallet으로 마이그레이션되었습니다.',
    skSourceManagedTip: '이 앱은 서버 관리 지갑으로 실행되고 있습니다. 더 나은 보안을 위해 DID Wallet으로 최대한 빨리 마이그레이션하십시오.',
    zeroDowntime: '무중단'
  },
  dashboard: {
    nodeDid: '노드',
    ownerDid: '소유자',
    routingEngine: '라우팅 엔진',
    ownerNftURL: 'NFT 소유자',
    expirationLeft: '만료까지 남은 시간',
    startFromCrashTip: '블록렛 서버가 마지막으로 정상적으로 종료되지 않았으므로 실행해야 할 블록렛을 수동으로 시작하십시오.',
    runtimeConfig: {
      blockletMaxMemoryLimit: 'Blocklet 최대 메모리 제한',
      daemonMaxMemoryLimit: '서버 최대 메모리 제한'
    },
    document: '문서에서 자세히 알아보세요',
    database: '데이터베이스'
  },
  store: {
    nameSort: '이름',
    popularSort: '인기',
    headerDescription: 'Blocklets을 찾아 설치하세요',
    detail: {
      purchase: '{name}을 구입하세요',
      open: '{name}을/를 열기',
      install: '{name}을/를 설치하세요',
      upgrade: '{name}를 업그레이드하세요',
      empty: '소개 없음'
    },
    blockletRegistry: {
      changeFailed: '블록렛 스토어 변경 실패',
      addFailed: '블록렛 스토어 추가 실패',
      editFailed: 'Blocklet 스토어 편집 실패',
      switchRegistry: '스위치 블록릿 스토어',
      addRegistry: '블록렛 스토어 추가',
      editRegistry: '블록렛 스토어 편집',
      deleteRegistry: 'Blocklet Store 삭제하기',
      haveSameRegistry: '동일한 블록렛 저장소가 존재합니다',
      registryName: '블록렛 스토어 이름',
      registryUrl: 'Blocklet Store의 URL',
      registryNameEmpty: 'Blocklet 스토어 이름은 비어 있을 수 없습니다',
      registryUrlEmpty: '블록렛 스토어 URL은 비워 둘 수 없습니다',
      deleteDesc: '블록렛 스토어 {name} 삭제 확인?<br/><span style="color: {color}">*이 블록렛 스토어를 삭제한 후에는 다시 추가하지 않는 한, 이 블록렛 스토어에서 설치된 앱을 업데이트할 수 없습니다.</span>',
      confirmDesc: '{name}을 삭제하려면 입력하세요'
    },
    purchase: {
      title: '{name} 구매',
      confirmed: '블록렛 구매 NFT가 확인되었습니다',
      declined: '유효한 블록렛 NFT 구매 정보를 제공하지 않았습니다.',
      waiting: '구매 완료 대기 중...',
      purchase: {
        title: 'NFT 구매하기',
        description: '이 블록렛을 설치하기 전에 일부 토큰을 지불하십시오. 이 블록렛을 아직 구매하지 않았다면'
      },
      verify: {
        title: 'NFT 확인',
        description: '이 블록릿을 설치하기 전에, 구매한 NFT를 소유 중인지 확인하기 위해 NFT가 검증될 것입니다',
        auth: {
          title: '구매 자격이 필요합니다',
          scan: '블록렛 구매를 위해 DID 지갑을 연결하여 NFT 제공',
          confirm: '귀하의 DID 지갑에서 이 작업을 검토하세요',
          success: 'NFT 구매가 확인되었으며 설치가 시작되었습니다'
        }
      },
      auth: {
        title: '{name}을/를 구매하다',
        scan: 'DID 지갑으로 아래의 QR 코드를 스캔하세요',
        confirm: '계정에서 확인',
        success: 'DID 지갑으로 전송된 NFT 구매'
      },
      launch: '{name}을(를) 실행합니다',
      autoLaunch: '{name}의 구매가 성공적으로 완료되었습니다. 시작 페이지로 이동 중입니다...'
    },
    tooltip: {
      upgradeServer: 'Blocklet에 Blocklet Server 버전 {version}이 필요하며 현재 Blocklet Server 버전은 {serverVersion}입니다.'
    }
  },
  setting: {
    saveSuccess: '설정이 성공적으로 저장되었습니다',
    unSavedTip: '저장되지 않은 변경 사항이 있습니다. "변경 사항 저장"을 클릭하여 저장하십시오.',
    unSavedLeaveTip: '저장되지 않은 변경 사항이 있습니다. 페이지를 떠나시겠습니까?',
    form: {
      name: '서버 이름',
      nameRequired: '서버 설명이 필요합니다',
      namePlaceholder: '서버 이름',
      description: '서버를 설명해주세요',
      descriptionHolder: '서버 설명',
      descriptionRequired: '서버 설명이 필요합니다',
      domain: '서버 도메인 이름',
      domainPlaceholder: '서버 도메인 이름',
      domainRequired: '서버 도메인이 필요합니다',
      ipPlaceholder: 'IP',
      ipRequired: 'IP가 필요합니다',
      registry: 'Blocklet Store',
      registryPlaceholder: '블록렛 스토어에서 블록렛 가져오기',
      registryRequired: 'Blocklet 스토어가 필요합니다',
      registerUrl: 'Blocklet Launcher URL',
      registerUrlPlaceholder: '선호하는 블록렛 런처의 URL을 입력하세요. 공식 런처를 안전하게 사용할 수 있습니다',
      webWalletUrl: 'DID 지갑 URL',
      webWalletUrlPlaceholder: "호스팅된 'DID 지갑'의 URL을 입력하세요. 안전하게 공식 지갑을 사용할 수 있습니다",
      nftDomainUrl: 'NFT 도메인 URL',
      nftDomainUrlPlaceholder: '호스팅된 "NFT 도메인"의 URL을 입력하세요. 공식 사이트를 안전하게 사용할 수 있습니다',
      enableWelcomePage: '환영 페이지 사용 설정',
      welcome: {
        switchLabel: '환영 페이지'
      },
      upgrade: {
        title: 'Blocklet 서버를 {version}로 업그레이드하세요',
        description: '업그레이드 중에는 Blocklet 서버가 업데이트가 완료될 동안 몇 분 동안 유지보수 모드로 전환됩니다.',
        dialog: '"확인"을 클릭하여 업데이트를 설치하십시오. 업데이트가 완료될 때까지 Blocklet 서버는 유지 보수 모드로 전환되며 자동으로 제품 모드로 돌아갑니다.',
        confirm: '업그레이드',
        switchLabel: '자동 업데이트 확인',
        enableBetaRelease: '베타 릴리스 활성화',
        setup: '업그레이드 준비 중',
        installing: 'Blocklet 서버 v{version}을(를) 설치 중입니다',
        restarting: 'Blocklet 서버 재시작 중입니다',
        cleanup: 'Blocklet 서버 데이터 이전 중입니다',
        verifying: 'Blocklet 서버 v{version} 확인 중',
        rollback: '로백 블록렛 서버',
        complete: '업그레이드 완료!',
        progress: '{name} 업그레이드 중',
        check: '업데이트 확인',
        latest: '최신 버전을 실행 중입니다.'
      },
      restart: {
        title: 'Blocklet 서버 재시작',
        description: '재시작 중에 재시작이 완료될 때까지 Blocklet 서버가 유지 보수 모드로 진입합니다.',
        dialog: '"확인"을 클릭하여 재시작하십시오. Blocklet Server는 재시작이 완료될 때까지 유지 보수 모드로 전환되며 자동으로 생산 모드로 복귀합니다.',
        confirm: '재시작',
        setup: '재시작 준비 중',
        verifying: '블록렛 서버 확인',
        restarting: 'Blocklet 서버 재시작 중입니다',
        cleanup: '모든 것이 정상인지 확인하세요',
        rollback: '더러운 상태 정리하기',
        complete: '정비 완료!',
        progress: '{name}를 다시 시작합니다'
      },
      register: {
        title: 'Blocklet Launcher에 등록하기',
        description: '추가되면 {url}에서이 블록렛 서버로 블록렛을 실행할 수 있습니다',
        button: '등록'
      },
      monitor: {
        diskThreshold: '디스크 사용량이 (%) 이상인 경우 경고 메시지 보내기',
        diskThresholdPlaceholder: '디스크 사용량 경고 임계값을 설정해주세요'
      },
      security: {
        switchLabel: '파일 시스템 격리',
        switchTips: '이 옵션을 사용 중지 한 후에는 더 이상 Blocklet의 파일 시스템이 격리되지 않아 악성 소프트웨어가 파일 시스템을 손상시킬 수있는 위험이 있습니다.',
        warningTips: '파일 시스템 격리 기능이 적용되지 않습니다. node.js 버전({version} 현재 버전)을 v21.6.0 이상으로 업그레이드하세요.'
      },
      docker: {
        switchLabel: '컨테이너에서 블록릿 실행하기',
        switchTips: '이 옵션을 활성화 한 후에는 블록이 컨테이너를 사용하여 실행되어 서버의 전반적인 보안이 향상될 수 있습니다.',
        notInstalled: '도커가 설치되어 있지 않거나 실행에 필요한 권한이 부족하여 컨테이너 실행을 활성화할 수 없습니다',
        needCloseFileSystemIsolation: '파일 시스템 격리 및 도커 컨테이너 모드런타임은 동시에 활성화될 수 없습니다'
      },
      dockerNetwork: {
        switchLabel: '컨테이너 네트워크 격리',
        switchTips: '이 옵션을 활성화하면 블록렛이 보다 안전한 방식으로 실행됩니다. 블록렛은 다른 응용프로그램에 있는 블록렛이나 블록렛 서버에 접근할 수 없습니다.',
        needEnableDocker: '컨테이너 모드를 활성화해야 네트워크 격리를 사용할 수 있습니다'
      },
      restartAllContainers: {
        title: '모든 컨테이너 다시 시작',
        description: '모든 컨테이너를 재시작하고 Blocklets 실행 유지.',
        dialog: '"확인"을 클릭하여 모든 컨테이너 Blocklets를 재시작하고 Blocklets 상태를 실행 중으로 유지합니다.',
        confirm: '재시작',
        setup: '재시작 준비 중',
        verifying: 'Blocklet Server 검증 중',
        restarting: '백그라운드에서 모든 컨테이너 재시작 중',
        cleanup: '모든 것이 정상인지 확인하세요',
        rollback: '더러운 상태 정리',
        complete: '완전히 유지하세요!',
        progress: '백그라운드에서 모든 컨테이너 재시작'
      },
      restartAllBlocklet: {
        title: '모든 Blocklets 재시작',
        description: '이 서버에서 실행 중이거나 오류가 발생한 모든 Blocklets를 다시 시작합니다.',
        dialog: '“확인”을 클릭하여 모든 Blocklets를 백그라운드에서 재시작하세요.',
        confirm: '재시작',
        setup: '재시작 준비 중',
        verifying: 'Blocklet Server 검증 중',
        restarting: '백그라운드에서 실행 중이거나 오류가 발생한 Blocklets를 모두 다시 시작합니다',
        cleanup: '모든 것이 정상인지 확인하세요',
        rollback: '오염된 상태 정리',
        complete: '유지보수 완료!',
        progress: '백그라운드에서 실행 중이거나 오류가 있는 모든 Blocklets 를 재시작 중입니다'
      },
      enableSessionHardening: {
        switchLabel: '세션 하드닝 활성화',
        switchTips: '이 옵션을 활성화하면 변경 작업에 엄격한 검증이 필요하며, 서버의 전반적인 보안이 향상될 수 있습니다.'
      }
    },
    accessKey: {
      accessKeyId: '액세스 키 ID',
      lastUsed: '마지막으로 사용된 시각',
      tip: '이 접근 키의 이름을 입력하세요',
      saveSecretTip: '이것은 액세스 비밀 키를 볼 수 있고 복구 할 수없는 유일한 시간입니다. 그러나 언제든지 새 액세스 키를 생성할 수 있습니다',
      iKnow: 'Access Secret을 복사하여 저장했습니다',
      showSecret: '비밀 액세스 키 표시',
      hideSecret: '비밀 숨기기',
      title: '액세스 키 삭제',
      descriptionNoTime: '이는 이전에 사용되지 않은 이름이 {name}이며 액세스 키 {key}를 영구적으로 삭제합니다',
      description: '이 작업은 이름이 {name}이고 마지막으로 사용한 시간이 {time}, {timeAge}인 액세스 키 {key}를 영구적으로 삭제합니다.',
      confirm_desc: '{name}을 삭제하려면 입력하세요',
      remark: '액세스 키 이름',
      remarkInvalid: '액세스 키 이름이 필요합니다',
      passport: '권한을 부여하거나 제한하기 위한 액세스 키의 여권을 선택하십시오',
      expireTime: '보안 강화를 위해 접근 키의 만료일을 설정하세요',
      authType: '인증 유형',
      resourceType: '리소스 유형',
      resourceId: '리소스 ID',
      component: '컴포넌트',
      expired: '{time} 만료됨',
      accessKeySecret: '액세스 키 비밀',
      simple: '간단한',
      signature: '서명',
      signatureDesc: '엔터프라이즈급 보안 표준, 암호화 사용. SDK (@blocklet/server-js)와의 코드 통합 필요. 보안 요구사항이 높고 중요 데이터 전송이 필요한 시나리오에 적합합니다',
      simpleDesc: '경량 베어러 토큰 메커니즘은 OpenAPI 키와 유사하며 RESTful API 호출 및 타사 서비스 통합을 지원합니다. 코딩이 필요 없으며 HTTP 헤더를 통해 빠르게 통합할 수 있어 신속한 개발에 적합합니다',
      viewSecret: '나중에 접근 키 상세 페이지에서 비밀 키에 접근할 수 있습니다',
      usage: '사용',
      listTitle: '액세스 키로 안전한 API 접근을 관리합니다',
      tooltipTitle: '신뢰할 수 있는 시스템이 프로그래밍 방식으로 여러분의 앱과 상호 작용할 수 있도록 자격 증명을 생성하고 관리합니다. 액세스 키는 안전한 자동화와 여러분의 도구 및 서비스 간의 원활한 통합을 가능하게 합니다.'
    },
    webhook: {
      add: '통합 추가',
      delTitle: '통합 삭제하기',
      requiredError: '유효한 {type}을(를) 제공해주세요',
      confirm_desc: '{name}을(를) 삭제하려면 입력하세요',
      test: '시험',
      description: 'ID {id} 와의 통합이 영구적으로 삭제됩니다',
      columns: {
        description: 'ID',
        params: '파라미터',
        createdAt: '생성일은'
      },
      testSuccess: '테스트 메시지가 성공적으로 전송되었습니다'
    },
    dns: {
      step1Title: '도메인 등록 기관에 로그인하세요',
      step1Desc1: '도메인 등록 기관에 로그인하여 도메인 관리 페이지를 찾고 네임 서버 설정 페이지를 찾으세요. 도메인 등록 기관은',
      step2Title: '2. {url} 의 DNS 설정을 찾습니다',
      step2Desc: '이것은 "DNS 관리", "고급 설정" 또는 이와 유사한 이름으로 불릴 수 있습니다.',
      step3Title: '3. 다음 DNS 레코드를 추가하십시오',
      step3Desc: '이름은 "host", "hostname", 또는 "alias" 라고 부를 수 있습니다'
    },
    domain: {
      addingDomain: '도메인 추가 중...',
      checkingResolvable: '도메인 상태를 확인하는 중입니다...',
      cannotResolve: '{domain} 을(를) 확인할 수 없습니다. DNS 설정을 확인하십시오',
      resolvedAddressError: '{domain} 이 {curDomain} 을 가리키는 CNAME 레코드로 제대로 구성되지 않았습니다',
      invalidDNSReminder: '{error}。 하지만 도메인을 계속 추가할 수는 있지만 자동 인증서 생성은 사용할 수 없습니다.',
      continueAdd: '계속 추가',
      conflictTitle: '{domain} 은 이미 사용 중입니다',
      conflictDescription: '{domain} 은(는) 이미 "{title}" 에서 사용 중입니다. 확인을 클릭하면, 도메인이 "{from}" 에서 삭제되고 "{to}" 에 추가됩니다.'
    },
    aigne: {
      modelAdapter: '모델 제공자',
      modelName: '모델 이름',
      desc: {
        modelAdapter: 'AI 모델 서비스를 제공하는 플랫폼',
        modelName: '특정 모델 버전 또는 모델 이름',
        key: '인증에 사용되는 {provider} API 키',
        baseUrl: '귀하의 AIGNE Hub 인스턴스 URL 을 입력하세요(예: https://hub.aigne.io). 직접 호스팅하는 경우 자신의 URL 을 사용하세요.',
        accessKeyId: '모델에 액세스하기 위한 고유 키 ID',
        secretAccessKey: '액세스 키 ID 와 쌍을 이루는 비밀 키',
        docLink: '자세한 내용과 API 참조는 공식 문서를 확인하세요'
      },
      configDesc: 'Blocklet을 AIGNE Hub와 통합하여 대규모 언어 모델(LLMs)에 대한 안전한 라우팅 액세스를 활성화하십시오. 연결되면 Blocklet과 해당 구성 요소는 지능적인 요청을 보내고 즉시 더 똑똑해질 수 있습니다. 자체 호스팅 <a href="{url}" target="_blank">AIGNE Hub</a> 또는 기본 공용 인스턴스를 사용할 수 있습니다.',
      failed: 'AIGNE 구성 저장 실패',
      authorizeAigneHub: '{name} 에 연결',
      baseUrl: 'AIGNE Hub URL',
      disconnect: '연결 해제',
      disconnectConfirm: 'AIGNE Hub 에서 연결을 끊으시겠습니까? 이렇게 하면 현재 AI 구성이 제거됩니다.',
      disconnectSuccess: 'AIGNE Hub 에서 성공적으로 연결 해제되었습니다',
      disconnectFailed: 'AIGNE Hub 연결 해제 실패',
      testConnection: '{provider} 연결 테스트',
      invalidUrl: '{provider} URL 이(가) 유효하지 않습니다',
      description: '현재 구성은 {name} 이(가) 실행 중일 때 적용됩니다. 적용하려면 Blocklet을 저장하고 다시 시작해야 합니다.',
      revokeUrlAuthTitle: '{url} 변경을 확인하시겠습니까?',
      revokeUrlAuth: '{url} 를 변경하시겠습니까? 수정 후에는 권한이 무효가 되어 재승인이 필요합니다!',
      testSuccess: 'AIGNE Hub 에 성공적으로 연결되었습니다',
      check: '체크',
      apiKeyNotAuthorized: 'API 키가 인증되지 않았습니다. AIGNE Hub 연결 버튼을 클릭하여 인증하세요',
      switchUser: '사용자 전환',
      connectTimeOut: '{provider} 연결이 시간 초과되었습니다. 나중에 다시 시도하세요',
      restart: {
        title: 'Blocklet 다시 시작',
        connectedContent: '당신의 Blocklet 은 현재 {provider} 에 연결되어 있습니다. 구성은 재시작 후 적용됩니다. 지금 재시작하시겠습니까?',
        notConnectedContent: '귀하의 Blocklet 이 현재 {provider} 에서 연결이 끊어졌습니다. 설정은 재시작 후에 적용됩니다. 지금 재시작하시겠습니까?',
        confirm: '지금 재시작',
        cancel: '나중에 재시작'
      },
      testFailed: 'AIGNE Hub 에 연결할 수 없습니다. URL 또는 네트워크를 확인하세요.',
      addCredits: 'Credits 구매',
      transaction: '트랜잭션',
      connected: '성공적으로 연결되었습니다',
      account: '계정 정보',
      pendingCredit: '미결제 요금',
      infinite: '무제한',
      config: 'AIGNE Hub 구성'
    }
  },
  notification: {
    title: '알림',
    empty: '아직 활동이 없습니다',
    viewAll: '전체보기',
    showRead: '표시 읽기',
    markAllAsRead: '모두 읽음 처리',
    markAsRead: '읽음으로 표시',
    proceed: '계속하다',
    checkingForUpdates: '업데이트 확인 중입니다...',
    email: {
      enable: '알림 활성화',
      from: '이메일 발신자',
      host: 'SMTP 서버 호스트',
      port: 'SMTP 서버 포트',
      user: 'SMTP 사용자 이름',
      secure: '안전한 연결',
      password: 'SMTP 비밀번호',
      fromRequired: '이메일 발신자는 필수입니다',
      fromInvalid: '이메일 발신자가 유효하지 않습니다',
      receiverRequired: '이메일 수신자는 필수입니다',
      receiverInvalid: '이메일 수신자가 잘못되었습니다',
      hostRequired: 'SMTP 서버 호스트가 필요합니다',
      hostInvalid: 'SMTP 서버 호스트가 잘못되었습니다',
      portRequired: 'SMTP 서버 포트는 필수입니다',
      portInvalid: 'SMTP 서버 포트가 잘못되었습니다. 포트는 1에서 65535 사이여야 합니다',
      userRequired: 'SMTP 서버 사용자 이름이 필요합니다',
      passwordRequired: 'SMTP 서버 사용자 비밀번호가 필요합니다.',
      testSuccess: '테스트 이메일이 성공적으로 전송되었습니다',
      testFailed: '테스트 이메일 전송 실패',
      testReceiver: '이메일 수신자',
      testSendEmail: '이메일 전송 테스트',
      inputTestReceiver: '테스트 수신자 이메일을 입력해주세요',
      disable: '이메일 알림 취소',
      disableDescription: '구독 해지 후에는 이메일 알림을 더 이상 받지 못합니다. 이메일 알림을 받으려면 다시 이 페이지에서 구독 할 수 있습니다.',
      unsubscribe: '이메일 알림 취소',
      unsubscribeDescription: '구독 해지 후에는 더 이상 이메일 알림을 받지 않습니다.',
      subscribe: '구독하기',
      subscribeDescription: '이메일 알림을 받으려면 설정 페이지에서 다시 구독하십시오.',
      companyName: '회사명',
      companyLink: '회사 링크',
      companyAddress: '회사 주소',
      supportEmail: '지원 이메일',
      emailInvalid: '이메일이 잘못되었습니다',
      linkInvalid: '링크가 잘못되었습니다. http 또는 https로 시작해야 합니다',
      signature: '서명',
      signatureTooltip: '이메일 서명은 하단에 사용되어 수신자에게 보낸 사람에 대한 중요한 정보를 제공합니다.'
    },
    comingSoon: '추가 알림 채널이 건설 중입니다',
    unsubscribe: '구독 해지',
    unsubscribeSucceed: '구독 해지가 성공했습니다',
    unsubscribeFailed: '구독 취소 실패',
    unsubscribeTokenRequired: '탈퇴 토큰이 필요합니다',
    unsubscribeTokenExpired: '구독 취소 토큰이 만료되었습니다',
    unsubscribeTokenInvalid: '구독 취소 토큰이 잘못되었습니다',
    installComponentError: '찾을 수 없는 미설치 구성 요소 {name}',
    installingComponent: '{name} 구성 요소를 설치 중입니다.',
    pushKit: {
      enable: '알림 활성화',
      endpoint: 'PushKit 엔드포인트',
      endpointInvalid: 'PushKit 끝점이 유효하지 않은 URL입니다',
      testSuccess: '테스트 PushKit이(가) 성공적으로 전송되었습니다',
      testFailed: '테스트 PushKit 전송 실패',
      testReceiver: '푸시킷 수신기',
      testSend: '푸시 키트 보내기 테스트',
      inputTestReceiver: '테스트 수신자 입력 did',
      receiverRequired: 'PushKit 수신기가 필요함',
      pushPath: '푸시-킷의 API 경로 (기본 /api/push)',
      did: 'PushKit Blocklet DID',
      customOptions: '사용자 정의 옵션'
    },
    notificationDetails: '알림 세부 정보',
    receiver: '수신기',
    sendStatus: {
      success: '전송됨',
      failed: '실패',
      sentTime: '전송 시간: {date}',
      pending: '보류 중',
      reason: {
        enabled: '사용자가 {channel} 알림을 활성화했습니다',
        disabled: '사용자는 {channel} 알림을 활성화하지 않았습니다',
        unavailable: '현재 Blocklet 에 {channel} 알림이 구성되어 있지 않습니다',
        available: '현재 Blocklet 은 {channel} 알림을 설정했습니다',
        notSent: '현재 메시지가 {channel} 에 전송되지 않았습니다',
        offline: '사용자가 오프라인 상태입니다'
      },
      count: '{count}',
      total: '총계'
    },
    filter: '필터',
    notificationPreview: '알림 미리보기',
    resend: '재전송',
    resendLimit: '하루에 최대 세 번 알림을 다시 보낼 수 있습니다.',
    from: '부터',
    to: '로',
    body: '몸',
    notificationTitle: '제목',
    createdAt: '생성일',
    status: '상태',
    system: '시스템',
    severity: '심각도',
    config: '설정',
    selectChannels: '채널 선택',
    selectChannelsTip: '다시 보낼 채널을 선택하세요',
    resendFailedOnly: '실패한 Channels 에만 다시 보내기',
    statistics: '통계',
    allSender: '모든 발신자',
    allSeverity: '모든 심각도',
    severityType: {
      info: '정보',
      success: '성공',
      warning: '경고',
      error: '오류'
    },
    clear: '지우기',
    allDone: '완료되었습니다',
    filterType: {
      all: '모든',
      unread: '읽지 않음'
    },
    viewMore: '더 보기'
  },
  router: {
    routerSetting: '도메인 및 URL',
    certSetting: 'SSL인증서',
    defaultSite: '기본 설정',
    urlHelperText: 'HTTP/HTTPS로 시작하지 않는 URL은 상대 경로로 간주됩니다',
    empty: 'URL 매핑 설정을 위해 작업을 클릭하세요',
    healthy: {
      ok: '블록렛 또는 서비스가 실행 중입니다.',
      error: '블록렛 또는 서비스가 작동하지 않거나 설치되지 않았습니다.'
    },
    service: {
      select: '블록렛 서비스 선택 (선택 사항)',
      what: 'Blocklet 서비스는 상위 블록렛으로 리디렉션하기 전에 요청에 대해 실행되는 파이프라인입니다'
    },
    nonProvider: {
      title: '엔진 교체 경고',
      description: '엔진을 없음으로 변경하면 이전 엔진이 중지되어 현재 페이지가 제대로 작동하지 않을 수 있습니다. 계속 진행하시겠습니까?',
      confirm: '이해했습니다, 계속 진행하세요'
    },
    validation: {
      urlRequired: 'URL이 필요합니다',
      redirectCodeRequired: '리다이렉트 코드가 필요합니다',
      didRequired: 'Blocklet이 필요합니다',
      pathPrefixTooLong: 'URL 접두사는 {length}자를 초과할 수 없습니다',
      pathPrefixCannotBeEmpty: 'URL 접두사는 비워둘 수 없습니다',
      domainRequired: '서버 도메인이 필요합니다',
      invalidUrl: '유효한 URL을 제공해주세요',
      pathPrefixRequired: 'URL 접두사가 필요합니다',
      redirectUrlRequired: '리디렉션 URL이 필요합니다',
      rewriteUrlRequired: '재작성 URL이 필요합니다'
    },
    domain: {
      addSite: '사이트 추가',
      validate: {
        emptyTip: '사이트 도메인은 비워둘 수 없습니다',
        suffixTip: '사이트 도메인은 {suffix}를 포함할 수 없습니다'
      },
      add: {
        title: '도메인 이름 추가',
        description: '유효한 도메인 이름을 제공해주세요',
        confirm: '추가',
        cancel: '취소',
        blocklet: 'Blocklet 선택하기',
        redirect: '트래픽을 어디로 리디렉션하시겠습니까?',
        port: '요청 핸들러는 어떤 포트를 청취해야합니까?',
        portTip: '이것은 요청 처리기의 주 포트로 기본 설정되어 있으며, 이를 사용자 정의할 수 있습니다',
        type: '교통 담당자',
        component: '구성 요소 선택하기',
        pageGroup: '페이지 그룹',
        pageGroupTip: '이 구성 요소는 위에 나열된 모든 페이지를 렌더링하거나, 빈칸으로 두어도 됩니다.'
      },
      update: {
        title: '사이트 도메인 업데이트',
        label: '사이트 도메인',
        description: '유효한 사이트 도메인을 제공해주세요'
      },
      setup: {
        tipStart: '도메인에 DNS 레코드를 추가하세요',
        tipEnd: '다음 지침에 따라',
        recordType: '레코드 유형',
        recordValue: '기록 값'
      },
      verify: {
        ok: '도메인 해석이 정상입니다',
        notResolved: '이 도메인은 해결되지 않고 접근할 수 없습니다. DNS 구성을 확인해주세요'
      },
      https: {
        ok: '이 도메인은 https가 활성화되어 있습니다',
        bad: '이 도메인은 https를 사용할 수 없습니다'
      },
      delete: {
        title: '사이트 삭제',
        description: '확인하면 기존의 "{name}" 사이트가 삭제됩니다. 변경 사항을 완료하려면 아래에 "{name}"을(를) 입력하고 삭제를 선택하십시오. 사이트를 유지하려면 취소를 선택하십시오.',
        confirm_desc: '{name}을(를) 확인하려면 입력하십시오'
      }
    },
    domainAlias: {
      nftDomain: 'DID 이름을 사용한 자동 구성',
      showTipHint: '도메인 이름 해결을 구성하는 방법은 어떻게 되나요?',
      add: {
        title: '추가 도메인 추가',
        domainDescription: '유효한 도메인 이름을 입력해주세요',
        forceTip: '도메인 이름이 이미 존재하는 경우 강제로 추가합니다',
        helperText: 'HTTP 또는 HTTPS URL이 입력되면 자동으로 도메인 이름으로 변환됩니다.',
        isDidDomainError: '이 도메인은 DID 도메인입니다. 자동 도메인 구성 방법을 사용하여 추가하십시오.',
        tips: 'DID Names 또는 다른 곳에서 구매한 도메인 이름을 입력할 수 있습니다. DID 도메인인 경우 DID 도메인 NFT를 제시해야 계속 진행할 수 있습니다.'
      },
      addCustomDomain: {
        name: '사용자 정의 도메인'
      },
      addDomainNFT: {
        showNFT: '도메인 자동으로 구성하기',
        tips: 'DID Names에서 구매한 도메인을 입력할 수 있습니다. DID 도메인이 감지되면 DID 도메인 NFT를 제시해야 계속할 수 있습니다.',
        connect: {
          scan: '다음 방법 중 하나를 사용하여 {domain}을 {appName}에 연결하세요',
          confirm: '계정에서 확인',
          success: '인증 성공',
          title: 'DID 이름을 {appName}에 연결합니다'
        },
        buyTip: 'DID 이름은 도메인 이름 확인을 자동으로 수행하므로 수동으로 구성할 필요가 없습니다. Blocklet 은 필요에 따라 도메인 이름의 확인 기록을 자동으로 업데이트합니다. 아직 DID Domain NFT가 없으면,',
        buy: 'DID 도메인 구매',
        topLevelDidDomainHint: 'DID 도메인의 경우, 최상위 도메인(예: example.com)을 입력하면 자동으로 www.example.com으로 설정됩니다',
        authorizeFailed: '도메인 NFT 정보를 가져오지 못했습니다. 다시 시도해주세요!'
      },
      delete: {
        title: '삭제',
        description: '“{domain}”을 삭제한 후 해당 별칭에 대한 접근이 제대로 처리되지 않을 수 있습니다.',
        confirmPlaceholder: '" {domain} "을 입력하여 삭제하십시오'
      },
      custom: '맞춤 도메인',
      noCustom: '사용자 정의 도메인 없음',
      noCustomTip: '웹사이트에 사용자 정의 도메인이 구성되어 있지 않습니다. 보안 강화 및 향상된 사용자 환경을 위해 사용자 정의 도메인을 구성하는 것이 좋습니다. 아래를 클릭하여 시작하십시오.'
    },
    domainSecurity: {
      title: '도메인 보안',
      cors: {
        title: '허용된 CORS 도메인',
        description: '{name}에게 크로스 오리진 요청을 보낼 수 있는 도메인 목록은 쉼표로 구분하고, 누구에게나 허용하려면 "*"를 사용할 수 있지만 권장하지 않습니다',
        domainInvalid: '유효한 도메인 이름 목록을 입력하세요'
      }
    },
    rule: {
      add: {
        title: 'URL 매핑 추가하기',
        confirm: '추가',
        pathPrefix: 'URL 접두사는 무엇인가요?',
        pathPrefixTip: "'/my-prefix'로 접두사를 설정하면 해당 접두사로 시작하는 모든 요청이 구성된 블록에 라우팅됩니다",
        blocklet: '어떤 블록이 그 요청을 처리하게 될까요?',
        port: '블록렛의 어떤 포트가 요청을 처리합니까?',
        portTip: '이것은 블록릿의 기본 포트로 설정됩니다. 블록릿이 여러 포트로 수신 대기하는 경우, 이를 사용자 정의할 수 있습니다',
        responseType: '응답 유형',
        responseBody: '응답 내용',
        responseBodyTip: '답변 내용을 여기에 붙여넣으세요. 4096자를 초과해서는 안 됩니다.',
        responseBodyRequired: '응답 내용은 비어 있을 수 없습니다'
      },
      delete: {
        title: 'URL 매핑 삭제하기',
        description: '확인하면 기존의 "{name}" URL 매핑이 삭제됩니다. 변경을 완료하려면 아래에 "{name}"을(를) 입력하고 삭제를 선택하십시오. URL 매핑을 유지하려면 취소를 선택하십시오.',
        confirm_desc: '{name}을(를) 삭제하려면 입력하세요',
        cancel: '취소'
      },
      update: {
        title: 'URL 매핑 업데이트',
        confirm: '네, 업데이트',
        cancel: '취소'
      }
    },
    cert: {
      name: '증명서명',
      domain: '도메인 이름',
      action: '액션',
      commonName: '일반 이름',
      boundDomains: '도메인',
      source: '출처',
      expired: '만료됨',
      leftDays: '남은 날',
      issuedOn: '발행일',
      expiryOn: '만료일까지',
      fingerprintAlg: '지문 알고리즘',
      validityPeriod: '유효 기간',
      matchedSites: '매치된 사이트',
      upload: '수동 업로드',
      publicCertHelperText: '공개 인증서를 다운로드할 수 있습니다',
      nonPublicCertHelperText: '비공개 인증서는 다운로드할 수 없습니다',
      protectedCertHelperText: '보호된 인증서는 편집할 수 없습니다',
      unprotectedCertHelperText: '보호되지 않은 인증서는 편집할 수 있습니다',
      issuing: '인증서 생성 중',
      sourceTypes: {
        upload: '수동 업로드',
        lets_encrypt: '암호화합시다'
      },
      table: {
        nodata: '데이터가 없습니다'
      },
      delete: {
        title: '인증서 삭제',
        description: '도메인 {domain}의 인증서를 삭제할까요? 삭제하면 관련 서비스에 영향을 줄 수 있습니다. 삭제를 진행하기 전에 안전한지 확인해 주세요.',
        confirm: '확인'
      },
      nginx: {
        title: '인증서 업데이트',
        titleAdd: '인증서 추가하기',
        pem: 'SSL 인증서 파일',
        pemTip: '서버 인증서 파일을 여기에 올려주세요. 파일은".pem" 또는 ".crt"로 끝나야 합니다',
        key: '개인 키 파일',
        keyTip: '서버 개인 키 파일을 여기에 넣어주세요. 파일의 확장자는 ".pem" 또는 ".key"로 끝나야 합니다',
        confirm: '저장',
        cancel: '취소',
        invalidFile: '잘못된 파일을 선택하셨습니다',
        empty: '아직 파일을 선택하지 않았습니다',
        source: '출처',
        sourceTypes: {
          upload: '수동 업로드',
          lets_encrypt: '암호화해 봅시다'
        }
      },
      detail: {
        title: '인증서 세부 정보'
      },
      genLetsEncryptCert: {
        title: "Let's Encrypt 인증서 생성하기",
        dnsTip: '도메인 이름이 현재 블록릿 서버를 가리키고 있는지 확인해주세요.',
        description: '인증서를 추가하면 서비스가 보다 안전해지며, Blocklet Server는 인증서가 만료되기 전에 자동으로 인증서를 갱신합니다.'
      }
    },
    gateway: {
      reqLimit: {
        switchLabel: '안정적인 성능을 위해 동시 요청 제한을 활성화합니다',
        rate: 'IP당 동시 요청을 초당 {rate}개로 제한 (IP별 제한)',
        title: '요청 제한',
        global: '게이트웨이에서 처리되는 동시 요청 수를 초당 {global}개로 제한합니다 (전역 제한)',
        burstFactor: '속도 제한의 버스트 팩터. 전역 및 IP별 제한에 적용됩니다 (global: {global}, per-IP: {rate})',
        methods: '다음 메서드에 대한 IP의 동시 요청 수 제한',
        burstDelay: '요청 폭주로 IP당 제한을 초과할 때의 지연 ({delay} 초)'
      },
      cacheEnabled: {
        switchLabel: '성능 향상을 위해 게이트웨이 캐시를 활성화',
        title: '게이트웨이 캐시'
      },
      blockPolicy: {
        switchLabel: '요청 차단',
        addItem: '항목 추가',
        blacklistDesc: '이 IP로부터의 요청은이 서버 및 모든 블록에 대한 액세스가 차단됩니다',
        inputPlaceholder: 'IP 주소, CIDR 범위 또는 URL을 입력하십시오',
        invalidItem: '잘못된 IP 주소, CIDR 범위 또는 URL',
        title: '요청 차단',
        autoBlocking: {
          switchLabel: '실시간 감지로 잘못된 요청 차단',
          windowSize: '요청을 계산하는 시간 창 크기 (초)',
          windowQuota: '창 내에서 허용되는 최대 요청 수 (IP 당)',
          blockDuration: '윈도우 내에서 할당량을 초과할 경우 IP로 사용자 차단 시간(초)',
          statusCodes: '확인할 상태 코드'
        }
      },
      proxyPolicy: {
        switchLabel: '프록시 뒤에서 실행 중',
        trustRecursive: '대리 프록시를 재귀적으로 신뢰하세요',
        trustRecursiveDesc: 'X-Forwarded-For 체인의 가장 왼쪽에 있는 IP 를 사용',
        trustedProxies: '신뢰할 수있는 프록시',
        trustedProxiesDesc: '이 IP에서의 요청은 실제 클라이언트 IP를 가져오는 데 신뢰됩니다',
        realIpHeaderLabel: '클라이언트 IP 헤더',
        realIpHeaderDesc: 'Blocklet 서버가 CloudFront와 같은 프록시 뒤에서 실행 중인 경우 여기에 클라이언트의 실제 IP 헤더를 설정할 수 있습니다.',
        addItem: '항목 추가',
        inputPlaceholder: 'IP 주소, CIDR 범위 입력',
        invalidItem: '잘못된 IP 주소, CIDR 범위',
        title: '프록시 정책'
      },
      wafPolicy: {
        switchLabel: 'ModSecurity 를 사용하여 악성 요청 감지 및 차단',
        modeDesc: 'Modsecurity 의 모드(modsecurity 모듈 필요)',
        mode: {
          detectOnly: '감지만 함 (요청 차단 안 함)',
          on: '켜짐 (요청을 차단합니다)'
        },
        logLevelDesc: 'ModSecurity 의 로그 레벨(0-9), 0 은 감사 로그 비활성화를 의미합니다',
        inboundAnomalyScoreThresholdDesc: '인바운드 이상 점수 임계값 (1-100), 값이 낮을수록 더 엄격함',
        outboundAnomalyScoreThresholdDesc: '아웃바운드 이상 점수 임계값 (1-100), 낮은 값은 더 엄격함을 의미함',
        docDesc: '문서를 확인하여 modsecurity 설정 방법을 확인하세요',
        title: '웹 애플리케이션 방화벽'
      }
    }
  },
  noMatch: {
    desc: '찾으시는 페이지를 찾을 수 없습니다'
  },
  health: {
    connectionErrorTip: 'Blocklet 서버가 네트워크에 연결할 수 없습니다. Blocklet 서버가 중지되었거나 네트워크에 문제가 있는지 확인해주세요.',
    connectionRecoveryTip: '블록렛 서버 연결이 복구되었습니다',
    connectionStoppedTip: 'Blocklet 서버가 중지되었습니다',
    wrongAccessUrlTip: '블록렛 서버 접근 주소가 잘못되었습니다. 올바른 접근 주소를 사용해주세요'
  },
  debug: {
    title: 'Blocklet 서버가 정상적으로 작동 중입니다!'
  },
  team: {
    invite: {
      action: '신규 초대',
      setting: '초대 설정',
      enabled: '이 설정을 비활성화하면 새 사용자 초대가 소유자/관리자로만 제한됩니다',
      disabled: '이 설정을 활성화하여 모든 사용자가 새 사용자를 초대할 수 있도록 허용합니다',
      inviter: '초대 받음'
    },
    add: '새로 추가하기',
    member: {
      name: '이름',
      passport: '여권',
      passports: '여권',
      lastLogin: '최종 로그인',
      lastLoginIp: '최근 로그인 IP',
      source: '소스 등록하기',
      source_derived: 'oauth에서 유래된',
      source_wallet: 'DID 지갑',
      filter: '필터링하기',
      blockAccess: '로그인 금지',
      blockAccessDescription: '사용자는이 응용 프로그램에 연결할 수 없습니다',
      allowAccess: '로그인 허용',
      allowAccessDescription: '사용자는이 응용 프로그램에 연결할 수 있습니다',
      updateRole: '역할 업데이트',
      removeUser: '사용자 삭제',
      removeUserDescription: '"{name}" 사용자를 삭제하시겠습니까?',
      revokePassport: '여권 철회',
      revokePassportDescription: '여권이 취소되면 여권 소지자는 다시 로그인에 사용할 수 없습니다. 계속하시겠습니까?',
      enablePassport: '여권 활성화',
      enablePassportDescription: '취소된 여권이 다시 활성화되면 여권 소지자는 다시 로그인에 사용할 수 있습니다. 계속하시겠습니까?',
      passportPermissionTitle: '여권에는 다음과 같은 권한이 있습니다:',
      search: '멤버 검색',
      onlyApprovedMember: '승인된 것만 표시',
      inviteDialog: {
        createInviteLink: '초대 링크 생성',
        createSuccessTip: '초대 링크가 성공적으로 생성되었습니다. 이 링크를 클릭하여 초대받은 회원에게 복사하여 보내시기 바랍니다. 이 초대 링크는 재사용할 수 없으며, {expireDate}에 만료됩니다.'
      },
      error: {
        passportEmpty: '여권은 비어 있으면 안 됩니다'
      },
      connectedAccounts: '연결된 계정',
      connections: '연결',
      federated: '연방의',
      switch: {
        did: 'DID 전환',
        profile: '프로필 변경',
        passport: '여권 바꾸기'
      },
      settings: {
        notification: '알림',
        email: '어떤 이벤트가 발생할 때 나에게 이메일을 보내주세요',
        wallet: '일부 이벤트가 발생할 때 내 지갑에 알림을 보내주세요',
        phone: '어떤 이벤트가 발생했을 때 나에게 문자 메시지를 보내주세요',
        webhook: 'Webhooks',
        add: '새로운 웹훅 추가하기',
        url: '사용자 정의 URL',
        slack: 'Slack Webhook',
        tested: '테스트 메시지가 전송되었습니다'
      },
      activeUserSessions: '활성 사용자 세션',
      forceLogout: '강제 로그아웃',
      forceLogoutDescription: '이 사용자를 강제로 로그아웃하시겠습니까?',
      openProfile: '프로필 보기',
      removeUserSuccess: '사용자가 성공적으로 제거되었습니다',
      forceLogoutRemoveDescription: '이 사용자를 강제 로그아웃하시겠습니까 (모든 사용자 세션도 제거)?'
    },
    transferNode: {
      name: '소유권 이전',
      inviteDialog: {
        title: 'Transfer Blocklet 서버',
        tips: {
          progress: '서버의 이전 작업을 완료하려면 수신자가 전송 요청을 수락해야합니다. 수락되면 현재의 여권으로는 서버에 다시 로그인할 수 없습니다.',
          newOwnerPermissions: '새로운 소유자는 회원, 여권 및 블록렛과 같은 모든 운영을 관리할 권리를 갖게 됩니다.',
          revoke: "이체 초대를 철회하려면, '팀 -> 멤버 -> 초대' 페이지에서 초대 링크를 삭제할 수 있습니다."
        },
        createInviteLink: '초대 링크 생성하기',
        createSuccessTip: '초대 링크가 성공적으로 생성되었습니다. 클릭하여 링크를 복사하고 초대할 멤버에게 링크를 보내주십시오. 이 초대 링크는 재사용할 수 없으며 {expireDate}까지만 유효합니다'
      },
      delegateDialog: {
        title: '인증이 필요합니다',
        scan: '서버 소유권 NFT를 이전하기 위해 다음 방법을 사용하십시오.',
        confirm: '계정에서 확인',
        success: '인증 성공'
      }
    },
    transferApp: {
      name: '소유권 이전',
      transferDialog: {
        title: '이적 신청',
        tips: {
          progress: '이전 신청은 수신자가 수락해야 이전 작업이 완료됩니다. 수신자가 수락한 후에는 현재 여권으로 애플리케이션에 로그인할 수 없게 됩니다.',
          newOwnerPermissions: '새로운 소유자는 회원, 여권 및 설정과 같은 모든 작업을 관리하는 권리를 갖게 될 것입니다.'
        },
        createTransferLink: '전송 링크 생성하기',
        createSuccessTip1: '전송 링크가 성공적으로 생성되었습니다. 초대 받은 사람은 <a style="color: rgb(29, 193, 199)" target="_blank" href="https://www.didwallet.io/">DID 지갑</a>을 사용하여 앱 소유권을 받아야 합니다',
        createSuccessTip2: '초대 회원에게 링크를 복사하여 보내주십시오. 이전 링크는 재사용할 수 없으며 {expireDate}에 만료됩니다. 이 대화 상자를 닫은 후에는 전송 링크가 한 번만 표시되며 다시 보이지 않습니다.',
        createSuccessTip3: '이체가 성공한 후, 애플리케이션은 자동으로 변경 사항을 적용하기 위해 재시작됩니다',
        link: '전송 링크',
        iKnow: '링크를 복사하여 저장했습니다'
      },
      connectDialog: {
        title: '승인이 필요합니다',
        scan: '다음 방법을 사용하여 애플리케이션의 소유권 이전을 승인하십시오.',
        confirm: '계정에서 확인',
        success: '인증 성공'
      },
      receiveDialog: {
        title: '신청 소유권 받기',
        scan: '다음 방법을 사용하여 애플리케이션 소유권을 받으세요.',
        confirm: '계정 에서 확인',
        success: '소유권을 성공적으로 받았습니다'
      },
      successTitle: '당신은 이 애플리케이션의 새로운 소유자가 되었습니다',
      visitDashboard: '어플리케이션 대시보드 방문하기',
      description: '응용 프로그램의 소유권을 다른 지갑이나 다른 사람에게 이전할 수 있습니다.'
    },
    permission: {
      create: {
        title: '권한 생성하기',
        description: "형식: <action>_<resource> 예: '사용자 조회', '사용자 변경'"
      },
      delete: {
        title: '권한 삭제',
        description: '{name} 삭제 확인?'
      },
      error: {
        actionEmpty: '동작은 비워둘 수 없습니다',
        resourceEmpty: '리소스는 비워둘 수 없습니다',
        permissionTooLong: '허가는 {length}자를 초과할 수 없습니다',
        descriptionTooLong: '설명은 {length}자를 초과할 수 없습니다'
      }
    },
    passport: {
      create: {
        title: '여권 발급',
        titleTip: '제목은 생성 후 수정할 수 없으며, 14자 이내로 권장됩니다'
      },
      bind: {
        title: '바인드 허가',
        roleTip: '연결 후, 선택한 여권의 모든 권한을 얻게 됩니다.',
        permissionTip: '바인딩 후 선택한 권한을 받게 됩니다',
        transferLeftTitle: '모든 권한',
        transferRightTitle: '허용된 권한'
      },
      delete: {
        title: '여권 삭제',
        description: '사용자가 소유한 여권은 삭제 후에 모든 권한을 잃습니다. 계속하시겠습니까?'
      },
      error: {
        titleEmpty: '제목은 비워 둘 수 없습니다',
        titleTooLong: '제목은 {length}자를 초과할 수 없습니다',
        descriptionEmpty: '설명은 비워둘 수 없습니다'
      },
      issuance: {
        pending: '보류 중',
        create: {
          title: '링크 생성'
        },
        delete: {
          title: '링크 수신 삭제',
          description: '{link}를 삭제하시겠습니까 확인하세요?'
        }
      },
      issue: '여권 발급',
      disableIssuance: '여권 발급 비활성화',
      enableIssuance: '여권 발급 허용',
      disableIssuanceTip: '"Issue Passport", "Invite Member" 및 기타 작업이 비활성화됩니다.',
      enableIssuanceTip: '"Issue Passport", "Invite Member" 및 기타 작업이 활성화됩니다',
      trustedPassportIssuers: '신뢰할 수 있는 여권 발급기관',
      trustedIssuers: '신뢰할 수 있는 발행자',
      trustedFactories: '신뢰할 수 있는 NFT 컬렉션',
      trustedFactoriesTip: '신뢰할 수 있는 NFT 컬렉션을 관리하여 여권으로 교환할 수 있습니다.',
      searchFactoryAddress: '콜렉션 DID 검색',
      configFactories: '신뢰할 수 있는 NFT 컬렉션 설정',
      configFactoriesTip: '사용자들이 NFT를 여권으로 교환할 수 있게 허용하다',
      factoryAddress: 'NFT 컬렉션 주소',
      factory404: 'NFT 컬렉션을 찾을 수 없습니다',
      factoryAddressTip: 'NFT 컬렉션 주소는 ArcBlock 메인 체인 상에 존재해야합니다',
      role: '여권 종류',
      ttl: '여권 만료 정책',
      ttlNever: '만료되지 않음',
      ttlMint: 'NFT 구매 이후',
      ttlExchange: '여권 교환으로 인해',
      ttlNeverTip: '여권은 취소될 때까지 유효합니다',
      ttlMintTip: 'NFT를 구매한 후에는 패스포트가 지정한 ttl이나 취소될 때까지 유효합니다',
      ttlExchangeTip: '여권은 사용자가 성공적으로 교환 한 시점부터 ttl 또는 취소를 지정할 때까지 유효합니다',
      ttlTip: '365d는 365일을 의미하며, 30일 또는 24시간도 사용할 수 있습니다',
      validUntil: '유효 기간: {date}',
      externalPassport: '외부 여권',
      notTrustedIssuerTip: '신뢰할 수 있는 발급자 목록에 발급자가 없기 때문에 여권을 사용할 수 없습니다',
      issuerDid: '발행자 DID',
      addNodeToTrustedIssuers: '현재 서버를 신뢰할 수 있는 여권 발급자로 추가하세요',
      revoked: '폐지된',
      noPermission: '이 작업을 수행할 권한이 없습니다',
      shouldNotDeleteCurrent: '현재 사용 중인 여권을 취소할 수 없습니다',
      mappingRule: '매핑 규칙',
      defaultRule: '기본 규칙',
      search: '여권 검색하기',
      searchIssuerDid: '발행자 DID 검색하기',
      issueBy: '{name}의 이슈',
      configColor: '여권 색상 설정',
      configColorTip: '여권의 색상을 사용자 정의하세요',
      color: '여권 색깔',
      description: '{teamName}을(를) {title}로 연결하기 위해 이 여권을 사용하세요',
      displayBuiltin: '기본 제공',
      displayCustom: '사용자 지정',
      typesTip: '여권 유형을 쉼표로 구분하여 맞춤화하세요',
      issuanceDate: '발행일: {date}',
      sourceMaps: {
        recover: '복구',
        issue: '발급됨',
        invite: '초대됨',
        trusted: '신뢰할 수 있는'
      },
      related: '관련 여권',
      operationLogs: '작업 로그',
      owner: '소유자',
      status: '상태',
      statusMap: {
        valid: '유효',
        revoked: '취소됨',
        expired: '만료됨'
      },
      view: '여권 관리',
      trustedPassportIssuersTip: '여권을 발급할 수 있는 신뢰할 수 있는 여권 발급 기관을 관리합니다',
      issuanceTime: '발행 시간',
      relatedDescription: '현재 여권은 다음 여권에서 파생되었습니다',
      passportExpireTime: 'Passport 만료 날짜 설정',
      customExpireTime: '사용자 지정 만료 시간',
      customExpireTimeIsInvalid: '사용자 지정 만료 시간이 유효하지 않습니다'
    },
    inviting: {
      link: '초대 링크',
      inviter: '초대자',
      delete: {
        title: '초대 링크 삭제하기',
        description: '{link}을(를) 삭제하시겠습니까?'
      },
      disabledTip: '초대가 사용되지 않음'
    },
    whoCanAccess: {
      all: {
        title: '모든 사람에게 액세스 가능'
      },
      owner: {
        title: '소유자 전용'
      },
      invited: {
        title: '초대된 사용자만'
      }
    },
    userFollowers: {
      follow: '팔로우',
      unfollow: '팔로우 취소',
      followersOnly: '팔로워에게만 보임',
      followers: '팔로워',
      following: '팔로잉',
      emptyFollowing: '아직 팔로우하는 사용자가 없습니다.',
      emptyFollowers: '아직 팔로워가 없습니다.',
      title: '팔로잉 & 팔로워',
      invitees: '초대 대상',
      emptyInvitees: '아직 아무도 초대하지 않았습니다.'
    },
    orgs: {
      explain: '사용자가 조직을 생성하고 참여하며 역할을 할당하고 자원을 관리할 수 있습니다.',
      description: '설명',
      deleteConfirm: '{name} 삭제를 확인하시겠습니까?',
      members: '멤버',
      myCreated: '내가 생성함',
      myJoined: '내 가입',
      myCreatedEmpty: '아직 조직을 만들지 않았습니다.',
      myJoinedEmpty: '아직 어떤 조직에도 참여하지 않았습니다.',
      deleteConfirmDescription: '이 조직을 삭제하면 연결된 모든 역할과 리소스가 제거됩니다. 사용자는 시스템에 남아 있지만 이 조직에서의 역할은 상실합니다. 이 작업은 되돌릴 수 없습니다.',
      active: '활성화됨',
      deleteOrg: '현재 조직 삭제',
      invitedAt: '초대일: {time}',
      joinedAt: '가입 시간: {time}',
      createNew: '새 조직 만들기',
      viewAll: '모든 조직 보기',
      validate: {
        nameEmpty: '이름은 비워둘 수 없습니다',
        nameTooLong: '이름은 {length} 자를 초과할 수 없습니다.',
        descriptionTooLong: '설명은 {length} 자를 초과할 수 없습니다'
      },
      mutate: {
        title: '{mode} 조직',
        name: '조직 이름',
        createSuccess: '조직이 성공적으로 생성되었습니다',
        updateSuccess: '조직이 성공적으로 업데이트되었습니다',
        orgNotEnabled: '조직이 활성화되지 않았습니다',
        maxMemberPerOrg: '조직은 최대 {maxMemberPerOrg}명의 멤버를 초대할 수 있습니다',
        maxOrgPerUser: '최대 {maxOrgPerUser} 개의 조직을 만들 수 있습니다'
      },
      invite: {
        chooseUsersToInvite: '초대할 사용자 선택',
        success: '사용자에게 초대장이 발송되었습니다',
        pleaseSelectUsers: '사용자를 선택하세요',
        pleaseSelectRole: '역할을 선택하세요',
        inviteExternalUsers: '외부 사용자 초대',
        failed: '{count} 사용자 초대에 실패했습니다. 나중에 다시 시도하세요',
        remove: '사용자 삭제',
        removeSuccess: '사용자 가 성공적으로 제거됨',
        limit: '제한',
        limitTip: '사용자별 org 구성원 및 org 제한',
        maxMembers: '조직별 최대 멤버 수',
        maxOrgs: '사용자당 최대 조직 수',
        maxMembersTip: '이 조직에 초대할 수 있는 최대 사용자 수',
        inviteLinkSendToEmail: '초대 링크가 이메일 ({email}) 로 전송되었습니다. 확인해 주세요.',
        enterEmailAddress: '이메일 주소를 입력하세요',
        inviteTitle: '{orgName}에 사용자를 초대하기'
      },
      member: {
        removeMemberConfirm: '{name} 을(를) 제거하시겠습니까?',
        removeMemberConfirmDescription: '제거 후 사용자는 조직 내 역할 및 권한을 잃게 됩니다. 이 작업은 취소할 수 없습니다.',
        removeInvitingMember: '{name} 초대 취소를 확인하시겠습니까?',
        removeInvitingMemberDescription: '제거 후, 사용자는 조직에 가입할 수 없으며 재초대가 필요합니다. 이 작업은 취소할 수 없습니다.'
      }
    }
  },
  launcher: {
    provider: '제공자',
    adminUrl: 'URL'
  },
  session: {
    blockAccess: '이 서버에 대한 액세스가 차단되었습니다'
  },
  launchBlocklet: {
    appInfo: '애플리케이션 정보',
    appInfoDesc: '신청 정보를 확인하세요',
    author: '애플리케이션 작성자: {author}',
    setup: '블록릿 설정',
    redirect: '리다이렉트',
    alreadyRunning: '{name} 애플리케이션이 이미 이 블록렛 서버에서 실행 중입니다',
    alreadyInstalled: '애플리케이션 {name}은(는) 이미 이 블록렛 서버에 설치되어 있습니다',
    alreadyExists: '이 애플리케이션은 이미 존재합니다, 리디렉션 중...',
    purchased: '이미 구매함',
    purchase: '구매',
    nextStep: '다음 단계',
    agreement: '라이선스 계약',
    agreeAll: '동의하고 계속하기',
    installing: '{serverName}에 {appName}을(를) 설치하는 중입니다. 완료까지 몇 분 정도 걸릴 수 있으니 기다려 주세요...',
    redirecting: '{appName}가 성공적으로 설치되었습니다. 지금 시작 중입니다...',
    start: '출시',
    launch: 'Blocklet을 서버에 설치하세요',
    launchSuccess: '{appName}가 성공적으로 출시되었습니다!',
    installSuccess: '{serverName}에서 Blocklet이 성공적으로 설치되고 실행되었습니다.',
    openInRegistry: 'Blocklet Store에서 보기',
    subTitle: '{serverName}에 Blocklet {appName}를 설치할 준비가 되었습니다',
    installingSubTitle: '{appName} 설치 중',
    access: '앱을 열어주세요',
    viewApplication: '애플리케이션 보기',
    newVersion: '새로운 버전',
    newVersionDesc: '해당 애플리케이션은 이미 존재하지만 현재 버전은 업그레이드할 수 있습니다',
    upgradeNow: '지금 업그레이드 하세요',
    later: '나중에',
    introduction: '소개',
    welcome: 'Blocklet 런치 마법사에 오신 것을 환영합니다',
    accept: '저는 Blocklet의 EULA에 동의합니다',
    license: '앱 라이선스',
    next: 'EULA에 동의하고 계속하기',
    purchaseApp: 'Blocklet 구매',
    setupAppDesc: 'Blocklet을 초기화하세요',
    launched: '완료',
    confirmInstall: '설치 확인',
    dialog: {
      title: '앱 소유자가 되세요',
      nftFreeDescription: '계속하기 위해 앱 공간 NFT를 제시하고 앱 계정을 만들어주세요',
      nftPaidDescription: '계속하려면 앱 공간 NFT와 앱 구매 NFT를 제시해주세요',
      freeDescription: '계속하려면 앱 계정을 만들어주세요',
      paidDescription: '앱 구매 NFT를 제시하고 앱 계정을 만들어 계속하십시오',
      confirm: '계정에서 확인하세요',
      success: '인증 성공',
      authorizationTimeout: '인증 시간이 초과되었습니다'
    },
    waiting: {
      verifying: '앱 메타데이터 확인 중...',
      downloading: '앱 번들 다운로드 중...',
      downloadingComponent: '{name} 다운로드 중입니다',
      extractingComponent: '{name} 추출 중',
      extracting: '앱 번들을 추출 중입니다...',
      installing: '앱 구성 요소 설치 중...',
      installed: '설치됨',
      starting: '앱을 시작 중...',
      done: '앱이 실행 중입니다...',
      parsing: '앱 메타데이터를 파싱하는 중...',
      initializing: '앱 구성을 초기화하는 중입니다...',
      initializingOwner: '앱 소유자 초기화 중...',
      creatingSecurityRules: '기본 보안 규칙 생성 중...',
      assigningDomain: '기본 도메인 할당 중...',
      waitingForDomain: '기본 도메인이 적용될 때까지 기다리는 중입니다...'
    },
    error: {
      loadMetaFailed: '앱 정보를 불러오는 데 실패했습니다',
      appMetaNotFound: '이 앱에 대한 정보를 찾을 수 없습니다',
      downloadFailed: '앱을 다운로드하는 데 실패했습니다. 다시 시도해주세요',
      installFailed: '앱 설치에 실패했습니다. 다시 시도해주세요',
      startFailed: '앱을 시작하지 못했습니다. 다시 시도해주세요',
      launchFailed: '앱을 실행하지 못했습니다. 다시 시도해주세요',
      installedButStopped: '앱은 성공적으로 설치되었지만 시작할 수 없습니다. 차단 문제를 해결한 후에 수동으로 시작할 수 있습니다',
      installedButError: '앱이 성공적으로 설치되었지만 시작하지 못했습니다',
      restoreFailed: '앱 복원 실패. 다시 시도해주세요',
      resourceBlocklet: '이 Blocklet은 직접 실행할 수 없지만, 기존 앱에 추가할 수 있습니다.'
    },
    steps: {
      introduction: '소개',
      installApp: '앱을 설치하세요',
      purchaseSpace: '공간 구매',
      prepareSpace: '공간 준비'
    },
    installRelatedComponents: '관련된 Blocklets 설치하기',
    canNotInstall: '설치할 수 없습니다',
    dockerBlockletCantInstall: 'Blocklet 을 설치할 수 없습니다. Blocklet Server 이 Docker 또는 Docker Network 를 활성화하지 않았기 때문입니다',
    nav: {
      myApps: '내 Apps',
      viewMyApps: '내 앱 보기'
    },
    withoutWallet: 'DID Wallet 연결 건너뛰기',
    nwFailed: '워크플로를 가져오는 데 실패했습니다.',
    alreadyConsumed: '런치 세션이 소모되었습니다',
    redirectToLauncherBlocklet: 'Launcher Blocklet으로 리디렉션 중입니다'
  },
  issuePassport: {
    title: '여권 받기',
    description: '다음 방법으로 {name}이 발급한 여권을 받으세요',
    dialog: {
      scan: '다음 방법으로 여권을 청구하십시오',
      confirm: '계정에서 확인',
      success: '여권이 지갑에 성공적으로 추가되었습니다',
      loginWithPassport: '이 여권을 통해 연결하세요',
      autoClose: '{seconds}초 후에 페이지가 자동으로 닫힙니다',
      autoJump: '페이지는 {seconds}s 후에 자동으로 이동합니다'
    }
  },
  lostPassport: {
    title: '여권 분실',
    description: '{name} 소유주는 다음 방법으로 여권을 찾을 수 있습니다. 회원은 여권 재발급을 위해 소유주에게 연락하십시오.',
    return: '검색 작업 취소, 홈페이지로 돌아갑니다',
    receivePassport: '여권 받기',
    recoverDialog: {
      title: '여권 복구',
      scan: '다음 방법으로 여권을 찾으세요',
      confirm: 'DID wallet에서 확인하세요',
      success: '정상적으로 가져왔습니다'
    },
    receiveDialog: {
      title: '여권 수령',
      scan: '다음 방법으로 여권을 받으세요',
      confirm: 'DID wallet에서 확인해주세요',
      success: '성공적으로 수신되었습니다'
    },
    recoverPassport: '여권 복구'
  },
  invite: {
    message: '{name}님이 {dapp}의 {role}로 초대합니다',
    success: '{dapp}에 성공적으로 가입하였습니다',
    receive: '받기',
    validUntil: '유효기간:',
    viewPermission: '보기 권한',
    emptyPermission: '빈 권한',
    open: '열다',
    description: {
      step1: '{wallet}을(를) 다운로드하고 설정하세요',
      step2: '여권을 받으려면 위의 버튼을 클릭하세요',
      step3: '받은 여권으로 {dapp}에 로그인하세요'
    },
    transferNFTDialog: {
      title: 'Blocklet 서버 {name}를 받아들이기',
      scan: '런처를 연결하여 블록릿 서버의 수신을 완료하세요.',
      confirm: 'DID 지갑에서이 작업을 검토하십시오',
      success: '성공적으로 연결되었습니다. 서버 수신 확인을 기다리는 중입니다'
    }
  },
  receive: {
    dialog: {
      title: '여권 수령',
      scan: '여권을 받으신 후 여권으로 애플리케이션에 로그인할 수 있습니다',
      confirm: '계정에서 확인',
      success: '연결에 성공하였습니다',
      scanWithDid: '{did} 계정을 사용하여 이 여권을 받으세요. 여권을 받은 후에는 여권을 사용하여 애플리케이션에 로그인할 수 있습니다.'
    }
  },
  navigation: {
    navigation: '내비게이션',
    actionFailed: '동작 실패',
    form: {
      themeConfig: '테마 설정',
      contentConfig: '콘텐츠 설정',
      title: '제목',
      titlePlaceholder: '내비게이션 제목을 입력해주세요',
      titleTooLong: '제목 길이는 {len}보다 작아야 합니다',
      description: '설명',
      descriptionPlaceholder: '내비게이션 설명을 입력해주세요',
      descriptionTooLong: '설명 길이는 {len}보다 작아야 합니다',
      icon: '기본 아이콘',
      iconPlaceholder: '아이콘을 선택하세요',
      invalidIcon: '아이콘이 잘못되었습니다',
      findMoreIcon: '더 많은 아이콘 찾기',
      link: '링크',
      linkPlaceholder: '내비게이션 링크를 입력해주세요',
      invalidLink: '링크가 유효하지 않습니다',
      component: '구성 요소',
      componentPlaceholder: '내비게이션 컴포넌트를 선택해주세요',
      role: '역할',
      rolePlaceholder: '네비게이션 역할을 선택해주세요',
      locale: '로케일',
      localePlaceholder: '추가할 로케일을 입력해주세요',
      localeExists: '{value}은(는) 이미 존재합니다',
      activeIcon: '활성 아이콘',
      activeColor: '활성 색상',
      color: '기본 색상',
      colorPlaceholder: '예: #FF0000',
      invalidColor: '색상이 유효하지 않습니다',
      searchIcons: '아이콘 검색',
      searchIconsPlaceholder: '예: mdi:home'
    },
    action: {
      add: '내비게이션 추가',
      addSub: '서브 내비게이션 추가',
      edit: '내비게이션 편집',
      hide: '내비게이션 숨기기',
      show: '내비게이션 보기',
      del: '내비게이션 삭제하기',
      new: '새로운',
      noAddSub: '제거된 컴포넌트는 하위 네비게이션을 추가할 수 없습니다',
      noEdit: '설치되지 않은 구성 요소는 편집할 수 없습니다',
      noDel: '내장된 탐색 삭제가 허용되지 않습니다',
      reset: '초기화',
      restConfirmTitle: '{section} 탐색을 기본값으로 재설정하시겠습니까?',
      restConfirmDesc: '사용자 지정 탐색이 지워지고 기본 항목으로 복원됩니다.',
      resetSuccessful: '초기화 성공',
      delTabBarTitle: '이 탭을 삭제하시겠습니까?',
      delTabBarDesc: '삭제 후, 탭은 내비게이션 목록에서 제거됩니다'
    },
    access: '접속',
    members: '구성원',
    passport: '여권',
    analytics: '분석',
    dashboard: '대시 보드',
    studio: '스튜디오',
    blockletService: '블록렛 서비스',
    didConnect: 'DID 연결',
    didSpaces: 'DID Spaces',
    website: '웹사이트',
    operations: '작업',
    integration: '통합',
    developer: '개발자'
  },
  storage: {
    spaces: {
      title: 'DID Spaces',
      tips: '팁',
      label: 'DID 공간 게이트웨이를 입력하세요',
      connected: {
        title: '연결된 DID 공간',
        tag: '연결됨'
      },
      connectedWithName: '{name}에 성공적으로 연결되었습니다',
      addedWithName: '{name}을(를) 성공적으로 추가했습니다',
      connects: '연결',
      reconnect: '재연결',
      addressCannotEmpty: '주소는 비워 둘 수 없습니다.',
      addressNotValid: '{url}은(는) 유효한 주소가 아닙니다',
      authorize: {
        title: '{appName}을(를) DID Spaces에 연결하세요',
        scan: '다음 방법을 사용하여 앱 {appName}이 DID Spaces에 연결할 수 있도록 허용합니다',
        success: '연결에 성공했습니다'
      },
      provideNFT: {
        title: '{appName}의 DID Spaces NFT를 보여주세요',
        scan: '다음 방법을 사용하여 앱 {appName}에서 DID Space NFT를 표시할 수 있도록 허용합니다',
        success: '성공적으로 연결되었습니다'
      },
      backup: {
        title: '백업',
        records: '백업 기록',
        without: '백업 없음',
        succeeded: '백업 성공',
        failed: '백업 실패',
        lastBackup: '마지막 백업 시간',
        lastBackupTip: '{time} 전에 마지막으로 성공적인 백업이 이루어졌습니다. "DID Spaces" 탭에서 백업 설정을 확인하십시오',
        noBackup: '백업 없음',
        noBackupTip: '아직 백업이 생성되지 않았습니다. 데이터와 설정을 보호하기 위해 정기적인 백업 설정을 권장합니다'
      },
      autoBackup: {
        title: '자동 백업',
        enabled: '자동 백업이 켜져 있습니다',
        disabled: '자동 백업이 꺼져 있습니다'
      },
      autoCheckUpdate: {
        title: '새 버전 알림 자동 확인',
        enabled: '새 버전 자동 확인이 켜져 있습니다.',
        disabled: '새로운 버전 자동 확인이 꺼져 있습니다'
      },
      backupSuccessfully: '백업이 성공적으로 완료되었습니다',
      restore: '복원하세요',
      restoreSuccessfully: '성공적으로 복원되었습니다',
      gateway: {
        title: '게이트웨이',
        select: 'DID 공간을 선택하세요',
        add: {
          title: 'DID 공간 추가하기',
          label: 'DID Spaces의 URL을 입력하세요',
          failed: 'DID 스페이스 추가 실패',
          invalidUrl: '잘못된 DID 공간 게이트웨이 URL',
          duplicate: '{name} 은(는) 이미 이 Blocklet에 연결되어 있습니다'
        },
        delete: {
          title: '연결 해제',
          succeeded: 'DID Space {name}을(를) 성공적으로 연결 해제했습니다',
          failed: '연결 해제에 실패했습니다',
          failedForSelected: '선택한 DID Space를 연결 해제할 수 없습니다',
          descForBackup: '연결 해제 후, 이 Blocklet에서 이 DID Space로의 백업은 불가능합니다. 연결 해제하시겠습니까?\n연결 해제 후, {name}에 다시 연결하여 백업 작업을 복원할 수 있습니다.',
          descForStorage: '연결 해제 후, 이 Blocklet에서 이 DID Space로의 데이터 저장은 불가능합니다. 연결 해제하시겠습니까?\n연결 해제 후, {name}에 다시 연결하여 데이터 저장 작업을 복원할 수 있습니다.'
        },
        connect: {
          title: 'DID 공간 연결하기',
          add: '지금 DID Spaces에 연결하세요',
          addTips: '아직 어떤 DID Space 에도 연결되지 않았습니다',
          switch: 'DID 공간 전환하기',
          switchTips: '{name}에 연결되었습니다',
          connected: '연결됨'
        },
        switch: {
          failedForMismatchSpace: '올바른 DID 공간 {name} 에 연결하세요'
        },
        connectTo: 'DID Spaces에 연결하세요'
      },
      strategy: {
        title: '백업 전략',
        autoBackup: '자동 백업',
        backupNow: '지금 백업하세요',
        viewBackupFiles: '백업 파일 보기'
      },
      progress: {
        title: '백업 진행 상황'
      },
      record: {
        title: '백업 기록',
        emptyData: '기록이 없습니다'
      },
      notYet: '아직 백업이 진행 중이 아닙니다...',
      connect: {
        now: '지금 연결하기',
        title: 'DID Spaces 연결하기',
        provider: '백업을 시작하려면 DID Space를 제공하세요',
        providerForStorage: '데이터 저장을 위한 DID Space 를 제공하십시오',
        useWallet: 'DID 지갑으로 연결하기',
        useWalletReconnect: 'DID 지갑으로 다시 연결하기',
        useSpaceGateway: 'DID Spaces 게이트웨이로 연결하기',
        useSpaceGatewayReconnect: 'DID Spaces 게이트웨이로 다시 연결하기',
        switchToSpace: 'DID Space로 전환',
        switchToSpaceSucceeded: 'DID Space {name} 로 전환되었습니다',
        succeeded: 'DID Spaces에 성공적으로 연결되었습니다',
        disconnect: '연결 해제',
        abortBlockletBackup: '백업 중지'
      },
      disconnected: {
        tag: '연결 해제',
        reconnectNow: '다시 연결하기'
      }
    },
    appLevel: {
      title: '앱 수준 저장',
      description: '앱에서 생성된 모든 데이터는 이 DID Space에 저장됩니다'
    }
  },
  log: {
    lastDays: {
      1: '최근 1일',
      7: '지난 1주일'
    }
  },
  oauth: {
    commonSettings: '일반 설정',
    save: '저장',
    saveSuccess: '저장되었습니다',
    saveFailed: '저장 실패',
    issued: '발행됨',
    thirdPartyLogin: '제3자 로그인',
    alreadyBindOAuth: '이미 제3자 로그인이 바인딩되었습니다',
    alreadyBindWallet: '이미 DID 지갑에 바인딩되었습니다',
    auth0: {
      enable: 'Auth0 로그인 활성화',
      domain: '도메인',
      domainDescription: 'Auth0 도메인이 필요합니다',
      clientId: '고객 ID',
      clientIdDescription: 'Auth0의 클라이언트 ID가 필요합니다',
      clientSecret: '클라이언트 시크릿',
      clientSecretDescription: 'Auth0 OAuth 애플리케이션 클라이언트 비밀이 필요합니다'
    },
    comingSoon: '더 많은 로그인 방법이 구축 중입니다',
    moreLogin: '로그인',
    federated: '페더레이티드 로그인',
    runTest: '시험',
    github: {
      enable: 'Github 로그인 활성화',
      clientId: '클라이언트 ID',
      clientIdDescription: 'Github OAuth 응용 프로그램 클라이언트 ID가 필요합니다',
      clientSecret: '클라이언트 시크릿',
      clientSecretDescription: 'Github OAuth 애플리케이션 clientSecret 정보가 필요합니다'
    },
    google: {
      enable: '구글 로그인 활성화',
      clientId: '고객 ID',
      clientIdDescription: 'Google OAuth 애플리케이션 클라이언트 ID가 필요합니다',
      clientSecret: '클라이언트 암호',
      clientSecretDescription: 'Google OAuth 애플리케이션 clientSecret이 필수입니다'
    },
    apple: {
      enable: 'Apple 로그인 활성화',
      teamId: '팀 ID',
      teamIdDescription: 'Apple OAuth 애플리케이션 팀 ID가 필요합니다',
      serviceId: '서비스 ID',
      serviceIdDescription: 'Apple OAuth 애플리케이션 서비스 ID가 필요합니다',
      keyId: '키 ID',
      keyIdDescription: 'Apple OAuth 애플리케이션 키 ID가 필요합니다',
      authKey: '인증 키',
      authKeyDescription: 'Apple OAuth 애플리케이션 인증 키가 필요합니다',
      bundleId: '번들 ID',
      bundleIdDescription: 'Apple OAuth 애플리케이션 번들 ID 필수'
    },
    oauth: '제 3자 로그인',
    authorize: 'OAuth 인증',
    client: {
      tab: 'OAuth 앱',
      name: '앱 이름',
      clientId: '클라이언트 ID',
      clientSecret: '클라이언트 시크릿',
      scope: '범위',
      redirectUris: '리다이렉트 URI',
      grantTypes: '권한 부여 유형',
      responseTypes: '응답 유형',
      tokenEndpointAuthMethod: '토큰 엔드포인트 인증 방법',
      actions: '액션',
      grantResponse: '허가 및 응답',
      metaContact: 'Meta & 연락처',
      clientUri: '클라이언트 URI',
      logoUri: '로고 URI',
      contacts: '연락처',
      tosUri: '이용 약관 URL',
      policyUri: '정책 URI',
      jwksSoftware: 'JWKS & Software',
      jwksUri: 'JWKS URI',
      jwks: 'JWKS',
      softwareId: '소프트웨어 ID',
      softwareVersion: '소프트웨어 버전',
      clientSecretExpiresAt: '클라이언트 시크릿 만료 시각',
      clientIdIssuedAt: '클라이언트 ID 발급일시',
      oauthAppDetails: 'OAuth 앱 세부 정보',
      oauthEndpoints: 'OAuth 엔드포인트',
      authorizationEndpoint: '인증 엔드포인트',
      tokenEndpoint: '토큰 엔드포인트',
      userinfoEndpoint: '사용자 정보 엔드포인트',
      registrationEndpoint: '등록 엔드포인트',
      endSessionEndpoint: '세션 종료 Endpoint',
      validate: {
        clientName: '앱 이름이 필요합니다',
        clientNameMinLength: '앱 이름은 3글자 이상이어야 합니다',
        clientUri: '홈페이지 URL이 필요합니다',
        clientUriInvalid: 'http:// 또는 https://로 시작하는 유효한 URL을 입력해주세요',
        redirectUris: '인증 콜백 URL이 필요합니다',
        redirectUrisInvalid: 'http:// 또는 https://로 시작하는 유효한 URL을 입력해주세요',
        contacts: '쉼표로 구분된 유효한 이메일 주소를 입력해주세요',
        tosUri: '서비스 약관 URL이 필요합니다',
        tosUriInvalid: '유효한 URL을 입력해주세요',
        policyUri: '정책 URL이 필요합니다',
        policyUriInvalid: '유효한 URL을 입력하세요',
        jwksUri: 'JWKS URI가 필요합니다',
        jwksUriInvalid: '유효한 URL을 입력하세요',
        jwks: 'JWKS가 필요합니다',
        jwksInvalid: '유효한 JWKS를 입력해주세요'
      },
      input: {
        clientName: '앱 이름',
        clientNamePlaceholder: '사용자가 알아보고 신뢰하는 것',
        clientUri: '홈페이지 URL',
        clientUriPlaceholder: 'https://your-app.com',
        redirectUris: '인증 콜백 URL',
        redirectUrisPlaceholder: 'https://your-app.com/callback',
        contacts: '연락 이메일',
        contactsPlaceholder: 'admin@your-app.com, support@your-app.com',
        permissions: '필요한 권한을 선택하세요',
        tosUri: '이용 약관 URL',
        tosUriPlaceholder: 'https://your-app.com/terms',
        policyUri: '정책 URL',
        policyUriPlaceholder: 'https://your-app.com/policy',
        jwksUri: 'JWKS URI',
        jwksUriPlaceholder: 'https://your-app.com/jwks',
        jwks: 'JWKS',
        jwksPlaceholder: 'JSON Web Key Set',
        expireTime: '보안 강화를 위해 클라이언트 시크릿의 만료 날짜를 설정하세요'
      },
      helperText: {
        clientName: '사용자들이 알아보고 신뢰하는 것',
        clientUri: '애플리케이션 홈페이지의 전체 URL',
        redirectUris: '귀하의 애플리케이션 콜백 URL',
        contacts: '애플리케이션 담당자의 이메일 주소',
        tosUri: '귀하의 애플리케이션 서비스 약관 URL。',
        policyUri: '귀하의 애플리케이션 개인정보처리방침 URL。',
        read: '읽어보세요 우리의',
        document: 'OAuth 문서',
        more: '자세한 내용은 여기에서 확인하세요.'
      },
      delete: {
        title: 'OAuth 클라이언트 삭제',
        description: '{clientName} OAuth 클라이언트를 삭제하시겠습니까?'
      },
      register: '새 OAuth 앱 생성',
      requiredInformation: '필수 정보',
      optionalInformation: '선택 정보',
      registerButton: '만들기',
      logo: 'Logo',
      openRegistration: '등록 시작',
      openidConfiguration: 'OpenID 구성',
      createUser: '만든 사람',
      update: 'OAuth 앱 업데이트',
      listTitle: 'OAuth 앱을 사용한 안전한 제3자 액세스 활성화',
      tooltipTitle: '앱의 내장 OAuth 서버를 사용하여 업계 표준 프로토콜로 외부 애플리케이션을 인증합니다. 안전하고 매끄러운 인증 및 위임된 액세스 제어를 통해 사용자에게 권한을 부여합니다.',
      empty: '데이터가 추가되지 않았습니다'
    },
    viewDocument: '문서 보기',
    twitter: {
      enable: 'X 로그인 활성화',
      clientId: '클라이언트 ID',
      clientIdDescription: 'X OAuth application 클라이언트 ID가 필요합니다',
      clientSecret: '클라이언트 비밀',
      clientSecretDescription: 'X OAuth 애플리케이션의 Client Secret 이 필요합니다'
    }
  },
  expiration: {
    mobile: {
      tips: {
        success: '안녕하세요, {validity}',
        warning: '{validity}',
        error: '만료되었습니다'
      },
      loadFailed: '다시 시도하세요!'
    },
    desktop: {
      tips: {
        success: '구독은 {validity} 후에 만료됩니다',
        warning: '구독이 {validity} 후에 만료됩니다',
        error: '구독이 만료되었습니다'
      },
      loading: '구독 불러오는 중...',
      loadFailed: '구독 정보를 불러오지 못했습니다. 다시 시도해주세요!',
      nextInvoice: '다음 송장: {date}'
    }
  },
  analytics: {
    trend: '트렌드',
    detail: '고장',
    traffic: {
      totalRequests: '총 요청 수',
      validRequests: '성공한 요청',
      failedRequests: '실패한 요청',
      uniqueVisitors: '고유 방문자',
      uniqueFiles: '고유한 URL',
      uniqueReferrers: '고유한 추천자',
      uniqueNotFound: '독특한 404',
      uniqueStaticFiles: '고유한 정적 파일',
      logSize: '로그 크기',
      bandwidth: '대역폭'
    },
    runtime: '런타임'
  },
  federated: {
    inviteJoinFederatedLogin: '연합 로그인에 참여하도록 초대하기',
    inviteJoinFederatedLoginDescription: '다음 주소를 복사하고 통합 로그인을 신청해야하는 응용 프로그램에 작성해주세요.',
    federatedLogin: '연합 로그인',
    joinFederatedLogin: '연합 로그인 가입하기',
    joinFederatedLoginDescription: 'Master Blocklet이 제공하는 연합 로그인 주소를 입력하여 연합 로그인에 참여해주세요',
    quitFederatedLogin: '연방 로그인 종료',
    quitFederatedLoginDescription: '연합 로그인 종료 후에는 일반 로그인이 항상 사용 가능합니다',
    federatedJoinAppUrl: 'appUrl에서 페더레이션 로그인에 참여하기',
    federatedJoinAppUrlRequired: '연합 로그인 가입 appUrl을 입력하세요',
    failedToGetFederatedLoginAppUrl: '연합 로그인 가입 앱 URL을 가져오지 못했습니다',
    federatedJoinAppUrlInvalid: '연합 로그인 appUrl이 잘못되었습니다',
    siteDetail: '사이트 세부 정보',
    approveToJoinLogin: '연합 로그인 가입 승인',
    approve: '로그인 활성화',
    revoke: '로그인 비활성화',
    enableFederatedLogin: '연합 로그인 활성화',
    disableFederatedLogin: '연합 로그인 비활성화',
    enableFederatedLoginDescription: '페더레이션 로그인을 활성화한 후에는이 사이트가 자동으로 로그인됩니다',
    disableFederatedLoginDescription: '연합 로그인을 비활성화한 후에는 이 사이트에서 자동 로그인되지 않습니다',
    enableFederatedAutoLogin: '자동 로그인 활성화하기',
    enableFederatedAutoLoginDescription: '자동 로그인을 활성화한 후에 현재 통합 로그인 상태가 있는 경우, 해당 사이트는 자동으로 통합 로그인 신분으로 로그인합니다.',
    disableFederatedAutoLogin: '자동 로그인 비활성화',
    disableFederatedAutoLoginDescription: '자동 로그인이 해제된 후에는 사이트가 통합 로그인의 사용자 정보로 자동으로 로그인하지 않게됩니다. 대신 통합 로그인 신분으로 수동으로 로그인을 클릭하여 로그인 할 수 있습니다.',
    info: {
      appId: 'APP이했습니다',
      appPid: '영구 ID',
      migratedFrom: '다른 이름으로 알려진',
      appName: '블록렛 이름',
      appDescription: '블록 설명',
      appUrl: '블록렛 URL',
      appLogo: 'Blocklet 로고',
      did: '블록 DID',
      serverId: '블록렛 서버 ID',
      serverVersion: '블록렛 서버 버전',
      version: '블록렛 버전',
      appliedAt: '지원하기',
      status: '상태'
    },
    status: {
      pending: '대기 중',
      approved: '승인됨',
      rejected: '거부됨',
      revoked: '취소된'
    },
    disbandFederatedLogin: '연합 로그인 해제',
    disbandFederatedLoginDescription: '연합 로그인을 해제한 후에는 모든 회원 사이트가 자동으로 연합 로그인을 종료합니다.',
    syncConfig: '연합 사이트 설정 동기화',
    quitMember: '제거',
    quitMemberDescription: '사이트 그룹에서 지정된 멤버 제거',
    removeFederatedLogin: '멤버 제거',
    removeFederatedLoginDescription: '사이트 그룹에서 지정된 멤버를 제거한 후, 멤버는 일반 로그인만 사용할 수 있습니다.',
    title: '페더레이티드 로그인이란 무엇입니까?',
    description: '페더레이티드 로그인은 여러 시스템에서 SSO(Single Sign-On)을 통해 달성할 수 있습니다. 다른 팀을 페더레이티드 로그인에 초대하거나 다른 조직의 페더레이티드 로그인 플랫폼에 적극적으로 참여할 수 있습니다.',
    link: '문서 보기'
  },
  optionsOrder: {
    1: '옵션 일',
    2: '옵션 둘'
  },
  securityRule: {
    title: '보안 규칙',
    sortByDescription: '일치 우선 순위로 정렬',
    add: '보안 규칙 추가',
    edit: '보안 규칙 편집',
    view: '보안 규칙 보기',
    form: {
      precede: '먼저 올리기',
      pathPattern: '경로 패턴',
      pathPatternPlaceholder: '패스 패턴 입력',
      pathPatternErrorText: '패스 패턴이 잘못되었습니다',
      accessPolicyOrResponseHeaderPolicyRequired: '액세스 정책 또는 응답 헤더 정책이 필요합니다',
      accessPolicy: '액세스 정책',
      accessPolicyPlaceholder: '액세스 정책을 선택하세요.',
      accessPolicyHelperText: '액세스 정책 선택',
      responseHeaderPolicy: '응답 헤더 정책',
      responseHeaderPolicyPlaceholder: '응답 헤더 정책 선택',
      responseHeaderPolicyHelperText: '응답 헤더 정책 선택하기',
      remark: '비고',
      remarkPlaceholder: '비고를 입력하세요',
      component: '컴포넌트',
      componentPlaceholder: '구성 요소를 선택하세요'
    },
    delete: {
      title: '보안 규칙 삭제?',
      description: '보안 규칙을 제거한 후에는 규칙이 더 이상 적용되지 않습니다'
    },
    useless: '쓸모없는 보안 규칙'
  },
  responseHeaderPolicy: {
    title: '응답 머리말 정책',
    add: '응답 헤더 정책 추가',
    edit: '응답 헤더 정책 편집',
    view: '응답 헤더 정책 보기',
    form: {
      name: '이름',
      namePlaceholder: '이름을 입력하세요',
      description: '설명',
      descriptionPlaceholder: '설명을 입력하세요',
      cors: {
        origin: 'Origin',
        originPlaceholder: '다음 도메인 형식을 지원합니다: http://www.example.com, http://*.example.com, http://www.example.com:8080, * (와일드카드는 권장하지 않습니다)',
        originHelperText: '도메인 이름은 http:// 또는 https://로 시작하고, 한 줄에 하나, 한 줄에 와일드카드 * 하나',
        methods: '방법',
        allowedHeaders: '허용되는 헤더',
        allowedHeadersPlaceholder: '* 기입이 권장됩니다. 다중행 입력을 지원합니다.',
        allowedHeadersHelperText: '서버에 OPTIONS 요청을 보낼 때 다음 요청에서 어떤 사용자 지정 HTTP 요청 헤더를 사용할 수 있는지 알려줍니다. 예: x-blocklet-version',
        exposedHeaders: '노출된 헤더',
        exposedHeadersPlaceholder: '다중 줄 입력 지원',
        exposedHeadersHelperText: 'Expose-Headers 구성하기, 예: X-Content-Range',
        maxAge: '최대 수명(초)',
        maxAgeHelperText: 'OPTIONS 요청으로 인해 얻은 결과의 유효 기간은 양수 정수여야 합니다',
        optionsSuccessStatus: '옵션 성공 상태',
        preflightContinue: '사전 검사 계속',
        credentials: '신임장',
        smartModeHelperText: '현재 응용 프로그램의 모든 도메인 이름과 페더레이션 로그인 사이트 그룹의 모든 도메인 이름을 자동으로 추가',
        smartMode: '스마트 모드'
      },
      originOverride: '원본 재정의',
      originOverrideHelperText: '애플리케이션의 로직이 이 응답 헤더를 무시하도록 허용할지 여부'
    },
    delete: {
      title: '응답 헤더 정책 삭제?',
      description: '응답 헤더 정책을 제거한 후에는 해당 정책이 더 이상 효과가 없습니다'
    }
  },
  accessPolicy: {
    title: '접근 정책',
    add: '액세스 정책 추가',
    edit: '접근 정책 편집',
    view: '액세스 정책 보기',
    form: {
      name: '이름',
      namePlaceholder: '이름을 입력하세요',
      description: '설명',
      descriptionPlaceholder: '설명을 입력해 주세요',
      roles: '액세스 역할',
      accessType: '액세스 유형'
    },
    delete: {
      title: '액세스 정책 삭제?',
      description: '액세스 정책을 삭제하면 정책이 더 이상 적용되지 않습니다.'
    }
  },
  didConnect: {
    genKeyPair: {
      title: 'Blocklet DID 생성',
      scan: '다음 방법을 사용하여 Blocklet DID를 생성하십시오',
      success: 'Blocklet DID가 성공적으로 생성되었습니다',
      successDesc: 'Blocklet DID가 성공적으로 생성되었습니다 (이후 게시에는 DID를 생성한 지갑을 사용해야 합니다)'
    },
    common: {
      invalidSession: '세션이 유효하지 않습니다',
      invalidSessionDesc: '세션이 존재하지 않거나 만료되었습니다',
      connectionError: '연결 실패'
    }
  },
  pagination: {
    next: '다음 페이지',
    previous: '이전 페이지',
    rowsPerPage: '페이지당:',
    displayRows: '의',
    jumpToPage: '페이지로 이동:'
  },
  webhookEndpoint: {
    createWebhook: 'Webhook 생성',
    createWebhookTitle: 'Webhook 생성',
    selectAllEvents: '모든 이벤트 선택',
    selectAllEventsTooltip: '사용 가능한 모든 이벤트 선택',
    selectedEventsCount: '{count}개의 이벤트 선택됨',
    selectedCount: '{count} 개 선택됨',
    eventsCount: '{count}개의 이벤트',
    saveWebhook: 'Webhook 생성',
    noAvailableEvents: '사용 가능한 이벤트가 없습니다',
    loadingEvents: '이벤트 로드 중...',
    loadingError: '이벤트 로드 실패: {message}',
    title: 'Webhooks',
    noWebhooksAdded: 'Webhook이 추가되지 않았습니다',
    validation: {
      urlRequired: 'URL이 필요합니다',
      urlInvalid: '유효한 URL을 입력해주세요',
      descriptionRequired: '설명이 필요합니다',
      eventRequired: '이벤트를 하나 이상 선택하세요'
    },
    hosted: '호스팅된 엔드포인트',
    add: 'Webhook 생성',
    addTip: '실시간 이벤트를 수신하기 위해 webhook 엔드포인트를 설정하세요',
    listen: '듣기 위해',
    version: 'API 버전',
    attempts: 'Webhook 시도',
    url: {
      label: 'URL',
      description: 'Webhook 엔드포인트 URL'
    },
    description: {
      label: '설명',
      description: '이 엔드포인트의 용도에 대한 선택적 설명'
    },
    events: {
      label: '들을 이벤트 선택',
      description: '안녕하세요, {name}.'
    },
    disabled: '비활성화됨',
    enabled: '활성화됨',
    disable: '비활성화',
    enable: '활성화',
    editWebhookTitle: 'Webhook 업데이트',
    updateWebhook: 'Webhook 업데이트',
    waitingForEvents: '이벤트 대기 중...',
    loadingMore: '불러오는 중...',
    loadMore: '더 보기',
    response: '응답',
    request: '요청',
    eventData: '이벤트 데이터',
    deleteWebhook: {
      title: 'Webhook 삭제? ',
      description: 'Webhook을 삭제한 후에는 더 이상 이벤트를 수신하지 않습니다'
    },
    success: '성공',
    listTitle: 'Webhooks로 실시간 이벤트 데이터 전송',
    tooltipTitle: '실시간 이벤트 알림을 보내 앱을 외부 시스템에 원활하게 연결합니다. Webhook은 도구와 서비스 전반에서 강력한 통합과 자동화된 워크플로우를 가능하게 합니다.',
    triggeredFrom: '이 웹훅은 시도에서 트리거되었습니다'
  },
  description: {
    environment: '현재 변수는 {name} 이 실행될 때 적용됩니다. 적용하려면 애플리케이션을 다시 시작해야 합니다.',
    preferences: '현재 변수는 {name} 이 실행될 때 적용됩니다. 저장 후 변경 사항이 적용되며, 애플리케이션을 다시 시작할 필요가 없습니다.'
  },
  preferencesFor: '설정 for {name}',
  environmentFor: '환경 for {name}',
  accessKey: '액세스 키',
  embed: {
    iconTip: '구독 정보 보려면 클릭하세요'
  },
  command: '명령',
  mcp: {
    listTitle: 'MCP 클라이언트에서 Blocklet에 접속',
    tooltipTitle: '이 Blocklet에서 지원하는 MCP 서버 목록을 탐색하고, 서버를 선택하여 클라이언트에서 참여하는 데 필요한 연결 명령어를 즉시 확인하세요.',
    endpoint: 'MCP 엔드포인트',
    available: '사용 가능한 MCP 서버',
    noServer: '사용 가능한 MCP 서버가 없습니다'
  },
  installCommand: '설치 명령어',
  label: {
    add: '추가',
    apply: '레이블 적용',
    manage: '라벨 관리',
    title: '라벨',
    description: '설명',
    systemLabel: '시스템 레이블',
    create: '레이블 생성',
    edit: '라벨 편집',
    name: '이름',
    slug: 'Slug',
    parentLabel: '상위 레이블',
    color: '색상',
    search: '레이블 검색',
    saveSuccess: '라벨이 성공적으로 저장되었습니다',
    delete: '삭제',
    deleteTip: '"{name}"을(를) 삭제하시겠습니까?',
    deleteSuccess: '라벨 이 성공적으로 삭제되었습니다',
    reassignTip: '이 레이블이 사용 중인 경우, 해당 항목을 다른 레이블에 다시 할당하십시오.',
    reassignTo: '새 레이블 선택',
    recently: '최근',
    noMatching: '레이블을 찾을 수 없습니다',
    noLabels: '아직 레이블이 생성되지 않았습니다',
    filter: '레이블 필터',
    createNewLabel: '"{name}" 새 레이블 생성',
    actionLabel: '레이블 일괄 할당',
    selectLabels: '레이블 선택',
    deleteDesc: '레이블을 삭제하면 해당 레이블은 더 이상 사용되지 않습니다. {name}를 삭제하시겠습니까?',
    nameRequired: '제목은 필수 항목입니다',
    nameMinLength: '제목은 최소 1자 이상입니다.',
    nameMaxLength: '제목은 64자 미만이어야 합니다.',
    slugRequired: 'Slug 은 필수 항목입니다.',
    slugMinLength: 'Slug 는 최소 1자 이상이어야 합니다',
    slugMaxLength: 'Slug 는 128자 미만이어야 합니다.',
    descriptionMaxLength: '설명은 255자 미만이어야 합니다.',
    colorRequired: '색상은 필수 항목입니다',
    colorInvalid: '색상이 유효하지 않습니다'
  },
  environmentTips: {
    delete: '이 행을 삭제하시겠습니까?',
    deleteForbidden: '사용자 정의 환경 변수의 키만 변경할 수 있습니다.'
  }
};