cosmos-explorer/src/Localization/ko/Resources.json

{
  "common": {
    "ok": "확인",
    "cancel": "취소",
    "close": "닫기",
    "save": "저장",
    "delete": "삭제",
    "update": "업데이트",
    "discard": "삭제",
    "execute": "실행",
    "loading": "로드 중",
    "loadingEllipsis": "로드 중...",
    "next": "다음",
    "previous": "이전",
    "yes": "예",
    "no": "아니요",
    "result": "결과",
    "learnMore": "자세한 정보",
    "getStarted": "시작",
    "retry": "다시 시도",
    "apply": "적용",
    "refresh": "새로 고침",
    "copy": "복사",
    "create": "만들기",
    "confirm": "확인",
    "open": "열기",
    "rename": "이름 바꾸기",
    "download": "다운로드",
    "upload": "업로드",
    "connect": "연결",
    "remove": "제거",
    "load": "로드",
    "publish": "게시",
    "browse": "찾아보기",
    "increaseValueBy1": "값을 1만큼 늘리기",
    "decreaseValueBy1": "값을 1만큼 줄이기"
  },
  "splashScreen": {
    "title": {
      "default": "Azure Cosmos DB 시작",
      "postgres": "Azure Cosmos DB for PostgreSQL 시작",
      "vcoreMongo": "Azure DocumentDB 시작(MongoDB 호환성 포함)"
    },
    "subtitle": {
      "default": "모든 규모에 대해 전역적으로 분산된 다중 모델 데이터베이스 서비스",
      "getStarted": "샘플 데이터 세트, 설명서 및 추가 도구를 시작하세요."
    },
    "quickStart": {
      "title": "빠른 시작 개시",
      "description": "빠른 시작 자습서를 시작하여 샘플 데이터 시작"
    },
    "newCollection": {
      "title": "새 {{collectionName}}",
      "description": "스토리지 및 처리량에 대한 새 컨테이너 만들기"
    },
    "samplesGallery": {
      "title": "Azure Cosmos DB 샘플 갤러리",
      "description": "확장성 있는 인텔리전트 앱 패턴을 보여 주는 샘플을 검색합니다. Cosmos DB 사용하여 개념에서 코드로 얼마나 빨리 이동할 수 있는지 확인해 보세요."
    },
    "connectCard": {
      "title": "연결",
      "description": "원하는 도구 사용을 선호하시나요? 연결해야 하는 연결 문자열 찾기",
      "pgAdmin": {
        "title": "pgAdmin으로 연결",
        "description": "pgAdmin을 선호하시나요? 여기에서 연결 문자열 찾기"
      },
      "vsCode": {
        "title": "VS Code와 연결",
        "description": "Visual Studio Code MongoDB 및 DocumentDB 클러스터 쿼리 및 관리"
      }
    },
    "shell": {
      "postgres": {
        "title": "PostgreSQL 셸",
        "description": "PostgreSQL의 셸 인터페이스를 사용하여 테이블 만들기 및 데이터 조작"
      },
      "vcoreMongo": {
        "title": "Mongo Shell",
        "description": "MongoDB의 셸 인터페이스를 사용하여 컬렉션 만들기 및 데이터 조작"
      }
    },
    "teachingBubble": {
      "newToPostgres": {
        "headline": "PGSQL을 Cosmos DB?",
        "body": "환영합니다. PGSQL을 Cosmos DB 시작에 대한 도움이 필요한 경우 샘플 데이터, 쿼리를 찾을 수 있는 위치는 다음과 같습니다."
      },
      "resetPassword": {
        "headline": "암호 만들기",
        "body": "암호를 아직 변경하지 않은 경우 지금 변경하세요."
      },
      "coachMark": {
        "headline": "샘플 {{collectionName}} 시작",
        "body": "샘플 데이터를 사용하여 샘플 컨테이너를 만드는 과정을 안내한 다음 데이터 탐색기를 둘러보겠습니다. 이 둘러보기 시작을 취소하고 직접 탐색할 수도 있습니다."
      }
    },
    "sections": {
      "recents": "최근 항목",
      "clearRecents": "최근 항목 지우기",
      "top3": "꼭 알아야 할 3가지",
      "learningResources": "학습 리소스",
      "nextSteps": "다음 단계",
      "tipsAndLearnMore": "팁 및 자세한 정보",
      "notebook": "Notebook",
      "needHelp": "도움이 필요하세요?"
    },
    "top3Items": {
      "sql": {
        "advancedModeling": {
          "title": "고급 모델링 패턴",
          "description": "데이터베이스를 최적화하기 위한 고급 전략을 알아봅니다."
        },
        "partitioning": {
          "title": "분할 모범 사례",
          "description": "데이터 모델 및 분할 전략을 적용하는 방법을 알아봅니다."
        },
        "resourcePlanning": {
          "title": "리소스 요구 사항 계획",
          "description": "다양한 구성 선택 사항에 대해 알아보세요."
        }
      },
      "mongo": {
        "whatIsMongo": {
          "title": "MongoDB API란?",
          "description": "MongoDB 및 해당 기능에 대한 Azure Cosmos DB 이해합니다."
        },
        "features": {
          "title": "기능 및 구문",
          "description": "장점 및 기능 살펴보기"
        },
        "migrate": {
          "title": "데이터 마이그레이션",
          "description": "데이터 이동을 위한 마이그레이션 전 단계"
        }
      },
      "cassandra": {
        "buildJavaApp": {
          "title": "Java 앱 빌드",
          "description": "SDK를 사용하여 Java 앱을 만듭니다."
        },
        "partitioning": {
          "title": "분할 모범 사례",
          "description": "분할의 작동 방식을 알아봅니다."
        },
        "requestUnits": {
          "title": "RU(요청 단위)",
          "description": "RU 요금을 이해합니다."
        }
      },
      "gremlin": {
        "dataModeling": {
          "title": "데이터 모델링",
          "description": "그래프 데이터 모델링 권장 사항"
        },
        "partitioning": {
          "title": "분할 모범 사례",
          "description": "분할의 작동 방식 알아보기"
        },
        "queryData": {
          "title": "데이터 쿼리",
          "description": "Gremlin을 사용하여 데이터 쿼리"
        }
      },
      "tables": {
        "whatIsTable": {
          "title": "Table API 무엇인가요?",
          "description": "테이블 및 해당 기능에 대한 Azure Cosmos DB 이해"
        },
        "migrate": {
          "title": "데이터 마이그레이션",
          "description": "데이터 마이그레이션 방법 알아보기"
        },
        "faq": {
          "title": "테이블 FAQ에 대한 Azure Cosmos DB",
          "description": "테이블 Azure Cosmos DB 대한 일반적인 질문"
        }
      }
    },
    "learningResources": {
      "shortcuts": {
        "title": "바로 가기 키 데이터 탐색기",
        "description": "Data Explorer를 탐색하는 키보드 단축키를 배워보세요."
      },
      "liveTv": {
        "title": "기본 사항 알아보기",
        "description": "Azure Cosmos DB Live TV 쇼 소개 및 비디오 방법을 시청하세요."
      },
      "sql": {
        "sdk": {
          "title": "SDK 사용 시작",
          "description": "Azure Cosmos DB SDK에 대해 알아봅니다."
        },
        "migrate": {
          "title": "데이터 마이그레이션",
          "description": "Azure 서비스 및 오픈 소스 솔루션을 사용하여 데이터를 마이그레이션합니다."
        }
      },
      "mongo": {
        "nodejs": {
          "title": "Node.js 사용하여 앱 빌드",
          "description": "Node.js 앱을 만듭니다."
        },
        "gettingStarted": {
          "title": "시작 가이드",
          "description": "시작하는 데 필요한 기본 사항을 알아보세요."
        }
      },
      "cassandra": {
        "createContainer": {
          "title": "컨테이너 만들기",
          "description": "컨테이너 만들기 옵션을 알아보세요."
        },
        "throughput": {
          "title": "처리량 프로비저닝",
          "description": "처리량을 구성하는 방법을 알아봅니다."
        }
      },
      "gremlin": {
        "getStarted": {
          "title": "시작 ",
          "description": "Gremlin 콘솔을 사용하여 만들기, 쿼리 및 트래버스"
        },
        "importData": {
          "title": "Graph 데이터 가져오기",
          "description": "BulkExecutor를 사용하여 대량 수집 데이터 알아보기"
        }
      },
      "tables": {
        "dotnet": {
          "title": ".NET 앱 만들기",
          "description": ".NET 앱에서 Table용 Azure Cosmos DB에 액세스하는 방법입니다."
        },
        "java": {
          "title": "Java 앱 빌드",
          "description": "Java SDK를 사용하여 Table 앱에 대한 Azure Cosmos DB 만들기 "
        }
      }
    },
    "nextStepItems": {
      "postgres": {
        "dataModeling": "데이터 모델링",
        "distributionColumn": "배포 열을 선택하는 방법",
        "buildApps": "Python/Java/Django를 사용하여 앱 빌드"
      },
      "vcoreMongo": {
        "migrateData": "데이터 마이그레이션",
        "vectorSearch": "벡터 검색을 사용하여 AI 앱 빌드",
        "buildApps": "Nodejs를 사용하여 앱 빌드"
      }
    },
    "learnMoreItems": {
      "postgres": {
        "performanceTuning": "성능 튜닝",
        "diagnosticQueries": "유용한 진단 쿼리",
        "sqlReference": "분산 SQL 참조"
      },
      "vcoreMongo": {
        "vectorSearch": "벡터 검색",
        "textIndexing": "텍스트 인덱싱",
        "troubleshoot": "일반적인 문제 해결"
      }
    },
    "fabric": {
      "buildTitle": "데이터베이스 빌드",
      "useTitle": "데이터베이스 사용",
      "newContainer": {
        "title": "새 컨테이너",
        "description": "데이터를 저장할 대상 컨테이너 만들기"
      },
      "sampleData": {
        "title": "샘플 데이터",
        "description": "데이터베이스에 샘플 데이터 로드"
      },
      "sampleVectorData": {
        "title": "샘플 벡터 데이터",
        "description": "text-embedding-ada-002를 사용하여 샘플 벡터 데이터 로드"
      },
      "appDevelopment": {
        "title": "앱 개발",
        "description": "SDK를 사용하여 앱을 빌드하려면 여기에서 시작하세요."
      },
      "sampleGallery": {
        "title": "샘플 갤러리",
        "description": "실제 엔드 투 엔드 샘플 가져오기"
      }
    },
    "sampleDataDialog": {
      "title": "샘플 데이터",
      "startButton": "시작",
      "createPrompt": "\"{{containerName}}\" 컨테이너를 만들고 샘플 데이터를 해당 컨테이너로 가져옵니다. 몇 분 정도 걸릴 수 있습니다.",
      "creatingContainer": "컨테이너 \"{{containerName}}\"을(를) 만드는 중...",
      "importingData": "\"{{containerName}}\"로 데이터를 가져오는 중...",
      "success": "샘플 데이터를 사용하여 \"{{containerName}}\"을 만들었습니다.",
      "errorContainerExists": "데이터베이스 \"{{databaseName}}\"의 컨테이너 \"{{containerName}}\"이(가) 이미 있습니다. 삭제하고 다시 시도하세요.",
      "errorCreateContainer": "컨테이너를 만들지 못했습니다. {{error}}",
      "errorImportData": "데이터를 가져오지 못했습니다. {{error}}"
    }
  },
  "contextMenu": {
    "newContainer": "새 {{containerName}}",
    "restoreContainer": "{{containerName}} 복원",
    "deleteDatabase": "{{databaseName}} 삭제",
    "deleteContainer": "{{containerName}} 삭제",
    "newSqlQuery": "새 SQL 쿼리",
    "newQuery": "새 쿼리",
    "openMongoShell": "Mongo Shell 열기",
    "newShell": "새 셸",
    "openCassandraShell": "Cassandra Shell 열기",
    "newStoredProcedure": "새 저장 프로시저",
    "newUdf": "새 UDF",
    "newTrigger": "새 트리거",
    "deleteStoredProcedure": "저장 프로시저 삭제",
    "deleteTrigger": "트리거 삭제",
    "deleteUdf": "사용자 정의 함수 삭제"
  },
  "tabs": {
    "documents": {
      "newItem": "새 항목",
      "newDocument": "새 문서",
      "uploadItem": "항목 업로드",
      "applyFilter": "필터 적용",
      "unsavedChanges": "저장되지 않은 변경 내용",
      "unsavedChangesMessage": "저장하지 않은 변경 내용이 손실됩니다. 계속하시겠습니까?",
      "createDocumentFailed": "문서 만들기 실패",
      "updateDocumentFailed": "문서 업데이트 실패",
      "documentDeleted": "문서를 삭제했습니다.",
      "deleteDocumentDialogTitle": "문서 삭제",
      "deleteDocumentsDialogTitle": "문서 삭제",
      "throttlingError": "트래픽률 제한 오류로 인해 일부 문서 삭제에 실패했습니다. 나중에 다시 시도하세요. 앞으로 이런 일이 없도록 컨테이너나 데이터베이스의 처리량을 늘려 보세요.",
      "deleteFailed": "문서 삭제 실패({{error}})",
      "missingShardProperty": "문서에 분할 속성이 없습니다. {{partitionKeyProperty}}",
      "refreshGridFailed": "문서 그리드 새로 고침 실패",
      "confirmDelete": "{{documentName}}을(를) 삭제하시겠습니까?",
      "confirmDeleteTitle": "삭제 확인",
      "selectedItems": "선택한 항목 {{count}}개",
      "selectedItem": "선택한 항목",
      "selectedDocuments": "선택한 문서 {{count}}개",
      "selectedDocument": "선택한 문서",
      "deleteDocumentFailedLog": "문서 {{documentId}}개 삭제 실패(상태 코드 {{statusCode}})",
      "deleteSuccessLog": "문서 {{count}}개를 삭제함",
      "deleteThrottledLog": "\"요청이 너무 큽니다\"(429) 오류로 인해 문서 {{count}}개를 삭제하지 못했습니다. 다시 시도하는 중...",
      "missingShardKeyLog": "새 문서 저장에 실패했습니다. 문서 분할 키가 정의되어 있지 않습니다.",
      "filterTooltip": "쿼리 조건을 입력하거나 목록에서 하나를 선택하세요.",
      "loadMore": "더 많이 로드",
      "documentEditor": "문서 편집기",
      "savedFilters": "저장된 필터",
      "defaultFilters": "기본 필터",
      "abort": "중단",
      "deletingDocuments": "문서 {{count}}개를 삭제하는 중",
      "deletedDocumentsSuccess": "문서 {{count}}개를 삭제했습니다.",
      "deleteAborted": "문서 삭제를 중단했습니다.",
      "failedToDeleteDocuments": "문서 {{count}}개를 삭제하지 못했습니다.",
      "requestTooLargeBase": "\"요청이 너무 큼\" 예외(429)로 인해 일부 삭제 요청이 실패했습니다.",
      "retriedSuccessfully": "하지만 다시 시도하여 성공했습니다.",
      "retryingNow": "지금 다시 시도 중입니다.",
      "increaseThroughputTip": "앞으로 이런 일이 없도록 컨테이너나 데이터베이스의 처리량을 늘려 보세요.",
      "numberOfSelectedDocuments": "선택한 문서 수: {{count}}개",
      "mongoFilterPlaceholder": "쿼리 조건자(예: {\"id\":\"foo\"})를 입력하거나 드롭다운 목록에서 하나를 선택하거나, 모든 문서를 쿼리하려면 비워두세요.",
      "sqlFilterPlaceholder": "쿼리 조건자(예: WHERE c.id=\"1\")를 입력하거나 드롭다운 목록에서 하나를 선택하거나, 모든 문서를 쿼리하려면 비워두세요.",
      "error": "오류",
      "warning": "경고"
    },
    "query": {
      "executeQuery": "쿼리 실행",
      "executeSelection": "선택 영역 실행",
      "saveQuery": "쿼리 저장",
      "downloadQuery": "쿼리 다운로드",
      "cancelQuery": "쿼리 취소",
      "openSavedQueries": "저장된 쿼리 열기",
      "vertical": "수직",
      "horizontal": "수평",
      "view": "보기",
      "editingQuery": "쿼리를 편집하는 증"
    },
    "storedProcedure": {
      "id": "저장 프로시저 ID",
      "idPlaceholder": "새 저장 프로시저 ID 입력",
      "idAriaLabel": "저장 프로시저 ID",
      "body": "저장 프로시저 본문",
      "bodyAriaLabel": "저장 프로시저 본문",
      "successfulExecution": "저장 프로시저 실행 성공",
      "resultAriaLabel": "저장 프로시저 결과 실행",
      "logsAriaLabel": "저장 프로시저 로그 실행",
      "errors": "오류:",
      "errorDetailsAriaLabel": "오류 세부 정보 링크",
      "moreDetails": "추가 세부 정보",
      "consoleLogTab": "console.log"
    },
    "trigger": {
      "id": "트리거 ID",
      "idPlaceholder": "새 트리거 ID 입력",
      "type": "트리거 유형",
      "operation": "트리거 작업",
      "body": "트리거 본문",
      "bodyAriaLabel": "트리거 본문",
      "pre": "사전",
      "post": "게시",
      "all": "모두",
      "operationCreate": "만들기",
      "operationDelete": "삭제",
      "operationReplace": "바꾸기"
    },
    "udf": {
      "id": "사용자 정의 함수 ID",
      "idPlaceholder": "새 사용자 정의 함수 ID 입력",
      "body": "사용자 정의 함수 본문",
      "bodyAriaLabel": "사용자 정의 함수 본문"
    },
    "conflicts": {
      "unsavedChanges": "저장되지 않은 변경 내용",
      "changesWillBeLost": "모든 변경 내용이 손실됩니다. 계속하시겠습니까?",
      "resolveConflictFailed": "충돌 확인에 실패했습니다.",
      "deleteConflictFailed": "충돌 삭제 실패",
      "refreshGridFailed": "문서 그리드 새로 고침 실패"
    },
    "mongoShell": {
      "title": "Mongo Shell"
    }
  },
  "panes": {
    "deleteDatabase": {
      "panelTitle": "{{databaseName}} 삭제",
      "warningMessage": "경고! 수행하려는 작업은 실행 취소할 수 없습니다. 계속하면 이 리소스와 모든 자식 리소스가 영구적으로 삭제됩니다.",
      "confirmPrompt": "{{databaseName}} ID(이름)를 입력하여 확인",
      "inputMismatch": "입력한 {{databaseName}} 이름 \"{{input}}\"이(가) 선택한 {{databaseName}} \"{{selectedId}}\"와(과) 일치하지 않습니다.",
      "feedbackTitle": "Azure Cosmos DB 개선에 도움을 주세요!",
      "feedbackReason": "이 {{databaseName}}을(를) 삭제하는 이유는 무엇인가요?"
    },
    "deleteCollection": {
      "panelTitle": "{{collectionName}} 삭제",
      "confirmPrompt": "{{collectionName}} ID를 입력하여 확인하세요",
      "inputMismatch": "입력한 ID {{input}}이(가) 선택한 {{selectedId}}와(과) 일치하지 않습니다.",
      "feedbackTitle": "Azure Cosmos DB 개선에 도움을 주세요!",
      "feedbackReason": "이 {{collectionName}}을(를) 삭제하는 이유가 무엇인가요?"
    },
    "addDatabase": {
      "databaseLabel": "데이터베이스 {{suffix}}",
      "databaseIdLabel": "데이터베이스 ID",
      "keyspaceIdLabel": "키스페이스 ID",
      "databaseIdPlaceholder": "새 {{databaseLabel}} ID 입력",
      "databaseTooltip": "{{databaseLabel}}은(는) 하나 이상의 {{collectionsLabel}} 논리 컨테이너입니다.",
      "shareThroughput": "{{collectionsLabel}} 전체에서 처리량 공유",
      "shareThroughputTooltip": "{{databaseLabel}} 수준에서 프로비전된 처리량은 {{databaseLabel}} 내의 모든 {{collectionsLabel}}에서 공유됩니다.",
      "greaterThanError": "autopilot 처리량에 대해 {{minValue}} 보다 큰 값을 입력하세요.",
      "acknowledgeSpendError": "예상 {{period}} 지출을 확인하세요.",
      "acknowledgeSpendErrorMonthly": "Please acknowledge the estimated monthly spend.",
      "acknowledgeSpendErrorDaily": "Please acknowledge the estimated daily spend.",
      "provisionSharedThroughputTitle": "Provision shared throughput",
      "provisionThroughputLabel": "Provision throughput"
    },
    "addCollection": {
      "createNew": "새로 만들기",
      "useExisting": "기존 항목 사용",
      "databaseTooltip": "데이터베이스는 네임스페이스와 유사합니다. 데이터베이스는 {{collectionName}} 집합을 관리하는 단위입니다.",
      "shareThroughput": "{{collectionName}}의 처리량 공유",
      "shareThroughputTooltip": "데이터베이스 수준에서 구성된 처리량은 데이터베이스 내 모든 {{collectionName}}에서 공유됩니다.",
      "collectionIdLabel": "{{collectionName}} ID",
      "collectionIdTooltip": "{{collectionName}}의 고유 식별자이며 REST 및 모든 SDK를 통해 ID 기반 라우팅에 사용됩니다.",
      "collectionIdPlaceholder": "e.g., {{collectionName}}1",
      "collectionIdAriaLabel": "{{collectionName}} ID, 예제 {{collectionName}}1",
      "existingDatabaseAriaLabel": "기존 {{databaseName}} ID 선택",
      "existingDatabasePlaceholder": "기존 {{databaseName}} ID 선택",
      "indexing": "인덱싱",
      "turnOnIndexing": "인덱싱 켜기",
      "automatic": "자동",
      "turnOffIndexing": "인덱싱 끄기",
      "off": "끄기",
      "sharding": "분할",
      "shardingTooltip": "분할된 컬렉션은 데이터를 여러 복제본 집합(샤드)에 분산하여 무제한 확장성을 제공합니다. 분할된 컬렉션을 사용하려면 데이터를 고르게 분산할 샤드 키(필드)를 선택해야 합니다.",
      "unsharded": "분할되지 않음",
      "unshardedLabel": "분할되지 않음(20GB 제한)",
      "sharded": "분할됨",
      "addPartitionKey": "계층형 파티션 키 추가",
      "hierarchicalPartitionKeyInfo": "이 기능을 사용하면 최대 3단계 키로 데이터를 분할해 데이터 분포를 개선할 수 있습니다. .NET V3, Java V4 SDK 또는 미리 보기 JavaScript V3 SDK가 필요합니다.",
      "provisionDedicatedThroughput": "이 {{collectionName}}에 대한 전용 처리량 프로비전",
      "provisionDedicatedThroughputTooltip": "필요에 따라 처리량이 프로비전된 데이터베이스 내의 {{collectionName}}에 대한 전용 처리량을 프로비전할 수 있습니다. 이 전용 처리량은 데이터베이스의 다른 {{collectionNamePlural}} 공유되지 않으며 데이터베이스에 대해 프로비전한 처리량에 포함되지 않습니다. 이 처리량은 데이터베이스 수준에서 프로비전한 처리량 외에도 요금이 청구됩니다.",
      "uniqueKeysPlaceholderMongo": "쉼표로 구분된 경로(예: firstName,address.zipCode)",
      "uniqueKeysPlaceholderSql": "쉼표로 구분된 경로 예: /firstName,/address/zipCode",
      "addUniqueKey": "고유 키 추가",
      "enableAnalyticalStore": "분석 저장소 사용",
      "disableAnalyticalStore": "분석 저장소 사용 안 함",
      "on": "켜기",
      "analyticalStoreSynapseLinkRequired": "분석 저장소 {{collectionName}}을(를) 만들려면 Azure Synapse Link가 필요합니다. 이 Cosmos DB 계정에서 Synapse Link를 사용하도록 설정하세요.",
      "enable": "활성화",
      "containerVectorPolicy": "컨테이너 벡터 정책",
      "containerFullTextSearchPolicy": "컨테이너 전체 텍스트 검색 정책",
      "advanced": "고급",
      "mongoIndexingTooltip": "_id 필드는 기본적으로 인덱싱됩니다. 모든 필드에 와일드카드 인덱스를 생성하면 쿼리가 최적화되어 개발에 권장됩니다.",
      "createWildcardIndex": "모든 필드에 와일드카드 인덱스 만들기",
      "legacySdkCheckbox": "내 애플리케이션은 이전 Cosmos .NET 또는 Java SDK 버전(.NET V1 또는 Java V2)을 사용합니다.",
      "legacySdkInfo": "이전 SDK와 호환되도록 생성된 컨테이너는 최대 101바이트 크기의 파티션 키 값을 지원하는 레거시 분할 방식을 사용합니다. 이 옵션을 사용하면 계층형 파티션 키를 사용할 수 없습니다.",
      "indexingOnInfo": "문서의 모든 속성은 유연하고 효율적인 쿼리를 위해 기본적으로 인덱싱됩니다.",
      "indexingOffInfo": "인덱싱이 꺼집니다. 쿼리를 실행하지 않거나 키 값 작업만 하는 경우 권장합니다.",
      "indexingOffWarning": "인덱싱이 꺼진 상태로 컨테이너를 만들면 인덱싱 정책을 변경할 수 없습니다. 인덱싱 정책이 있는 컨테이너에서만 인덱싱 변경이 허용됩니다.",
      "acknowledgeSpendErrorMonthly": "월별 예상 지출을 확인하세요.",
      "acknowledgeSpendErrorDaily": "예상 일별 지출을 확인하세요.",
      "unshardedMaxRuError": "분할되지 않은 컬렉션은 최대 10,000RU를 지원합니다.",
      "acknowledgeShareThroughputError": "이 전용 처리량의 예상 비용을 확인해 주세요.",
      "vectorPolicyError": "컨테이너 벡터 정책의 오류를 수정하세요.",
      "fullTextSearchPolicyError": "컨테이너 전체 텍스트 검색 정책의 오류를 수정해 주세요.",
      "addingSampleDataSet": "샘플 데이터 세트 추가",
      "databaseFieldLabelName": "Database name",
      "databaseFieldLabelId": "Database id",
      "newDatabaseIdPlaceholder": "Type a new database id",
      "newDatabaseIdAriaLabel": "New database id, Type a new database id",
      "createNewDatabaseAriaLabel": "Create new database",
      "useExistingDatabaseAriaLabel": "Use existing database",
      "chooseExistingDatabase": "Choose an existing database",
      "teachingBubble": {
        "step1Headline": "Create sample database",
        "step1Body": "Database is the parent of a container. You can create a new database or use an existing one. In this tutorial we are creating a new database named SampleDB.",
        "step1LearnMore": "Learn more about resources.",
        "step2Headline": "Setting throughput",
        "step2Body": "Cosmos DB recommends sharing throughput across database. Autoscale will give you a flexible amount of throughput based on the max RU/s set (Request Units).",
        "step2LearnMore": "Learn more about RU/s.",
        "step3Headline": "Naming container",
        "step3Body": "Name your container",
        "step4Headline": "Setting partition key",
        "step4Body": "Last step - you will need to define a partition key for your collection. /address was chosen for this particular example. A good partition key should have a wide range of possible value",
        "step4CreateContainer": "Create container",
        "step5Headline": "Creating sample container",
        "step5Body": "A sample container is now being created and we are adding sample data for you. It should take about 1 minute.",
        "step5BodyFollowUp": "Once the sample container is created, review your sample dataset and follow next steps",
        "stepOfTotal": "Step {{current}} of {{total}}"
      }
    },
    "addCollectionUtility": {
      "shardKeyTooltip": "샤드 키(필드)는 데이터를 여러 복제본 집합(샤드)에 분산해 무제한 확장성을 제공합니다. 데이터를 고르게 분산할 필드를 신중히 선택하는 것이 중요합니다.",
      "partitionKeyTooltip": "{{partitionKeyName}} 확장성을 위해 파티션 간에 데이터를 자동으로 분산하는 데 사용됩니다. 다양한 값을 갖고 요청 볼륨을 고르게 분산하는 JSON 문서의 속성을 선택하세요.",
      "partitionKeyTooltipSqlSuffix": " 읽기 작업이 적거나 쓰기 작업이 많은 모든 크기의 워크로드에는 id가 좋은 선택입니다.",
      "shardKeyLabel": "분할 키",
      "partitionKeyLabel": "파티션 키",
      "shardKeyPlaceholder": "e.g., categoryId",
      "partitionKeyPlaceholderDefault": "예: /address",
      "partitionKeyPlaceholderFirst": "필수 - 첫 번째 파티션 키(예: /TenantId)",
      "partitionKeyPlaceholderSecond": "두 번째 파티션 키(예: /UserId)",
      "partitionKeyPlaceholderThird": "세 번째 파티션 키(예: /SessionId)",
      "partitionKeyPlaceholderGraph": "e.g., /address/zipCode",
      "uniqueKeysTooltip": "고유 키는 개발자가 데이터베이스에 데이터 무결성 계층을 추가할 수 있게 합니다. 컨테이너 생성 시 고유 키 정책을 설정하면 파티션 키별로 하나 이상의 값이 고유함을 보장합니다.",
      "uniqueKeysLabel": "고유 키",
      "analyticalStoreLabel": "분석 저장소",
      "analyticalStoreTooltip": "트랜잭션 워크로드 성능에 영향을 주지 않고 운영 데이터에 대해 거의 실시간 분석을 수행할 수 있도록 분석 저장소 기능을 사용하도록 설정하세요.",
      "analyticalStoreDescription": "트랜잭션 워크로드 성능에 영향을 주지 않고 운영 데이터에 대해 거의 실시간 분석을 수행할 수 있도록 분석 저장소 기능을 사용하도록 설정하세요.",
      "vectorPolicyTooltip": "유사성 쿼리에 사용할 수 있도록 벡터가 포함된 데이터 속성을 설명하세요."
    },
    "settings": {
      "pageOptions": "페이지 옵션",
      "pageOptionsDescription": "고정된 쿼리 결과 수를 지정하려면 [사용자 지정]을 선택하고, 페이지당 최대 쿼리 결과를 표시하려면 [제한 없음]을 선택하세요.",
      "queryResultsPerPage": "페이지당 쿼리 결과",
      "queryResultsPerPageTooltip": "페이지당 표시할 쿼리 결과 수를 입력하세요.",
      "customQueryItemsPerPage": "페이지당 사용자 지정 쿼리 항목 수",
      "custom": "사용자 지정",
      "unlimited": "무제한",
      "entraIdRbac": "Entra ID RBAC 사용 설정",
      "entraIdRbacDescription": "Entra ID RBAC를 자동으로 사용하려면 [자동]을 선택하세요. 강제로 사용하거나 사용하지 않으려면 True/False를 선택하세요.",
      "true": "True",
      "false": "False",
      "regionSelection": "영역 선택",
      "regionSelectionDescription": "Cosmos 클라이언트가 계정에 액세스할 때 사용하는 지역을 변경합니다.",
      "selectRegion": "지역 선택",
      "selectRegionTooltip": "클라이언트 작업에 사용할 계정 끝점을 변경합니다.",
      "globalDefault": "전역(기본값)",
      "readWrite": "(읽기/쓰기)",
      "read": "(읽기)",
      "queryTimeout": "쿼리 시간 초과",
      "queryTimeoutDescription": "쿼리가 지정된 시간 제한에 도달하면 자동 취소가 설정되어 있지 않은 경우 쿼리를 취소할 수 있는 팝업이 표시됩니다.",
      "enableQueryTimeout": "쿼리 제한 시간 사용",
      "queryTimeoutMs": "쿼리 시간 제한(밀리초)",
      "automaticallyCancelQuery": "시간 초과 시 쿼리 자동 취소",
      "ruLimit": "RU 제한",
      "ruLimitDescription": "쿼리가 설정된 RU 제한을 초과하면 쿼리가 중단됩니다.",
      "enableRuLimit": "RU 제한 사용",
      "ruLimitLabel": "RU 제한(RU)",
      "defaultQueryResults": "기본 쿼리 결과 보기",
      "defaultQueryResultsDescription": "쿼리 결과를 표시할 때 사용할 기본 보기를 선택하세요.",
      "retrySettings": "설정 다시 시도",
      "retrySettingsDescription": "CosmosDB 쿼리 중 제한된 요청에 적용되는 재시도 정책입니다.",
      "maxRetryAttempts": "최대 재시도 횟수",
      "maxRetryAttemptsTooltip": "요청에 대해 수행할 최대 재시도 횟수입니다. 기본값 9.",
      "fixedRetryInterval": "수정된 재시도 간격(밀리초)",
      "fixedRetryIntervalTooltip": "응답에 포함된 retryAfter를 무시하고 각 재시도 사이에 대기하는 고정 재시도 간격(밀리초)입니다. 기본값은 0밀리초입니다.",
      "maxWaitTime": "최대 대기 시간(초)",
      "maxWaitTimeTooltip": "재시도 중 요청을 대기하는 최대 대기 시간(초)입니다. 기본값은 30초입니다.",
      "enableContainerPagination": "컨테이너 페이지 매김 사용 설정",
      "enableContainerPaginationDescription": "한 번에 50개의 컨테이너를 로드합니다. 현재 컨테이너는 영숫자 순서로 불러오지 않습니다.",
      "enableCrossPartitionQuery": "파티션 간 쿼리 사용 설정",
      "enableCrossPartitionQueryDescription": "쿼리를 실행하는 동안 두 개 이상의 요청을 보냅니다. 쿼리가 단일 파티션 키 값으로 제한되지 않은 경우 여러 요청이 필요합니다.",
      "maxDegreeOfParallelism": "최대 병렬 처리 수준",
      "maxDegreeOfParallelismDescription": "병렬 쿼리 실행 시 클라이언트 쪽에서 동시에 실행되는 작업 수를 가져오거나 설정합니다. 양수 값으로 설정하면 동시 작업 수가 해당 값으로 제한됩니다. 0보다 작게 설정하면 시스템이 자동으로 실행할 동시 작업 수를 결정합니다.",
      "maxDegreeOfParallelismQuery": "최대 병렬 처리 수준까지 쿼리",
      "priorityLevel": "우선 순위 수준",
      "priorityLevelDescription": "Priority-Based 실행 시 Data Explorer의 데이터 평면 요청 우선순위 수준을 설정합니다. \"없음\"을 선택하면 Data Explorer가 우선순위를 지정하지 않고 서버 기본 우선순위가 적용됩니다.",
      "displayGremlinQueryResults": "Gremlin 쿼리 결과 표시 방식:",
      "displayGremlinQueryResultsDescription": "쿼리 결과를 그래프로 자동 시각화하거나 JSON으로 표시하려면 Graph를 선택하세요.",
      "graph": "Graph",
      "json": "JSON",
      "graphAutoVisualization": "그래프 자동 시각화",
      "enableSampleDatabase": "샘플 데이터베이스 사용 설정",
      "enableSampleDatabaseDescription": "이 샘플 데이터베이스와 컬렉션은 NoSQL 쿼리를 탐색하는 데 사용할 수 있는 가상 제품 데이터를 포함합니다. Data Explorer UI에 별도의 데이터베이스로 표시되며, Microsoft가 비용 없이 생성하고 유지 관리합니다.",
      "enableSampleDbAriaLabel": "쿼리 탐색용 샘플 DB 사용 설정",
      "guidRepresentation": "GUID 표현",
      "guidRepresentationDescription": "MongoDB의 GuidRepresentation은 BSON 문서에 저장할 때 GUID(전역 고유 식별자)가 직렬화되고 역직렬화되는 방식을 나타냅니다. 모든 문서 작업에 적용됩니다.",
      "advancedSettings": "고급 설정",
      "ignorePartitionKey": "문서 업데이트 시 파티션 키 무시",
      "ignorePartitionKeyTooltip": "선택하면 업데이트 작업 시 파티션 키 값을 사용해 문서를 찾지 않습니다. 비정상적인 파티션 키로 인해 문서 업데이트가 실패할 때만 사용하세요.",
      "clearHistory": "기록 지우기",
      "clearHistoryConfirm": "계속 진행하시겠습니까?",
      "clearHistoryDescription": "이 작업을 수행하면 이 브라우저에서 이 계정에 대한 모든 사용자 지정이 다음을 포함해 지워집니다.",
      "clearHistoryTabLayout": "분할기 위치를 포함해 사용자 지정한 탭 레이아웃을 초기화합니다.",
      "clearHistoryTableColumns": "사용자 지정 열을 포함해 테이블 열 기본 설정을 지웁니다.",
      "clearHistoryFilters": "필터 기록 지우기",
      "clearHistoryRegion": "영역 선택을 전역으로 재설정",
      "increaseValueBy1000": "1000씩 값 늘리기",
      "decreaseValueBy1000": "값을 1000으로 줄입니다.",
      "none": "없음",
      "low": "낮음",
      "high": "높음",
      "automatic": "자동",
      "enhancedQueryControl": "향상된 쿼리 제어",
      "enableQueryControl": "쿼리 제어 사용 설정",
      "explorerVersion": "Explorer 버전",
      "accountId": "계정 ID",
      "sessionId": "세션 ID",
      "popupsDisabledError": "브라우저에서 팝업이 차단되어 이 계정에 대한 권한 부여를 설정할 수 없습니다.\n이 사이트에 대해 팝업을 허용한 후 \"Entra ID에 로그인\" 버튼을 클릭하세요.",
      "failedToAcquireTokenError": "권한 부여 토큰을 자동으로 가져오지 못했습니다. Entra ID RBAC 작업을 사용하려면 \"Entra ID 로그인\" 버튼을 클릭하세요."
    },
    "saveQuery": {
      "panelTitle": "쿼리 저장",
      "setupCostMessage": "규정 준수를 위해 쿼리를 \"{{databaseName}}\"이라는 별도의 데이터베이스 내 Azure Cosmos 계정의 컨테이너에 저장합니다. 계속하려면 계정에 컨테이너를 생성해야 하며, 예상 추가 비용은 하루 $0.77입니다.",
      "completeSetup": "설정 완료",
      "noQueryNameError": "쿼리 이름이 지정되지 않았습니다.",
      "invalidQueryContentError": "잘못된 쿼리 내용이 지정되었습니다.",
      "failedToSaveQueryError": "쿼리 {{queryName}}을(를) 저장하지 못했습니다.",
      "failedToSetupContainerError": "저장된 쿼리용 컨테이너 설정에 실패했습니다.",
      "accountNotSetupError": "쿼리를 저장하지 못했습니다. 계정이 쿼리 저장을 설정하지 않았습니다.",
      "name": "이름"
    },
    "loadQuery": {
      "noFileSpecifiedError": "지정된 파일이 없습니다.",
      "failedToLoadQueryError": "쿼리를 로드하지 못했습니다.",
      "failedToLoadQueryFromFileError": "{{fileName}} 파일에서 쿼리를 불러오지 못했습니다.",
      "selectFilesToOpen": "쿼리 문서 선택",
      "browseFiles": "찾아보기"
    },
    "executeStoredProcedure": {
      "enterInputParameters": "입력 매개변수 입력(있는 경우)",
      "key": "키",
      "param": "Param",
      "partitionKeyValue": "파티션 키 값",
      "value": "값",
      "addNewParam": "새 매개변수 추가",
      "addParam": "매개 변수 추가",
      "deleteParam": "매개변수 삭제",
      "invalidParamError": "잘못된 매개 변수를 지정했습니다. {{invalidParam}}",
      "invalidParamConsoleError": "잘못된 매개변수가 지정되었습니다. {{invalidParam}}은(는) 올바른 리터럴 값이 아닙니다.",
      "stringType": "문자열",
      "customType": "사용자 지정"
    },
    "uploadItems": {
      "noFilesSpecifiedError": "파일을 지정하지 않았습니다. 파일을 하나 이상 입력하세요.",
      "selectJsonFiles": "JSON Files 선택",
      "selectJsonFilesTooltip": "업로드할 JSON 파일을 하나 이상 선택하세요. 각 파일에는 단일 JSON 문서 또는 JSON 문서 배열이 포함될 수 있습니다. 한 번의 업로드 작업에서 모든 파일의 총 크기는 2MB 미만이어야 합니다. 더 큰 데이터 세트는 여러 번에 나누어 업로드할 수 있습니다.",
      "fileNameColumn": "파일 이름",
      "statusColumn": "상태",
      "uploadStatus": "{{numSucceeded}} 생성됨, {{numThrottled}} 제한됨, {{numFailed}} 오류 발생",
      "uploadedFiles": "업로드된 파일"
    },
    "copyNotebook": {
      "copyFailedError": "{{name}}을(를) {{destination}}(으)로 복사 실패",
      "uploadFailedError": "'{{name}}' 업로드 실패",
      "location": "위치",
      "locationAriaLabel": "위치",
      "selectLocation": "복사할 노트북 위치 선택",
      "name": "이름"
    },
    "publishNotebook": {
      "publishFailedError": "{{notebookName}}을(를) 갤러리에 게시하지 못했습니다.",
      "publishDescription": "게시하면 이 노트북이 Azure Cosmos DB 노트북 공개 갤러리에 표시됩니다. 게시 전에 민감한 데이터나 출력이 제거되었는지 확인하세요.",
      "publishPrompt": "\"{{name}}\"을(를) 게시하고 갤러리에 공유하시겠습니까?",
      "coverImage": "커버 이미지",
      "coverImageUrl": "표지 이미지 URL",
      "name": "이름",
      "description": "설명",
      "tags": "태그",
      "tagsPlaceholder": "선택 태그 1, 선택 태그 2",
      "preview": "미리 보기",
      "urlType": "URL",
      "customImage": "사용자 지정 이미지",
      "takeScreenshot": "화면 캡처",
      "useFirstDisplayOutput": "첫 번째 디스플레이 출력 사용",
      "failedToCaptureOutput": "첫 번째 출력을 캡처하지 못했습니다.",
      "outputDoesNotExist": "셀에 대한 출력이 없습니다.",
      "failedToConvertError": "{{fileName}}을(를) base64 형식으로 변환하지 못했습니다.",
      "failedToUploadError": "{{fileName}} 업로드 실패"
    },
    "changePartitionKey": {
      "failedToStartError": "데이터 전송 작업을 시작하지 못했습니다.",
      "suboptimalPartitionKeyError": "경고: 컬렉션이 최적이 아닌 파티션 키를 사용하고 있을 수 있습니다.",
      "description": "컨테이너의 파티션 키를 변경하려면 올바른 파티션 키를 가진 대상 컨테이너를 새로 만들어야 합니다. 기존 대상 컨테이너를 선택할 수도 있습니다.",
      "sourceContainerId": "원본 {{collectionName}} ID",
      "destinationContainerId": "대상 {{collectionName}} ID",
      "collectionIdTooltip": "{{collectionName}}의 고유 식별자이며 REST 및 모든 SDK를 통해 ID 기반 라우팅에 사용됩니다.",
      "collectionIdPlaceholder": "e.g., {{collectionName}}1",
      "collectionIdAriaLabel": "{{collectionName}} ID, 예제 {{collectionName}}1",
      "existingContainers": "기존 컨테이너",
      "partitionKeyWarning": "대상 컨테이너가 이미 존재하면 안 됩니다. Explorer가 새 대상 컨테이너를 생성합니다."
    },
    "cassandraAddCollection": {
      "keyspaceLabel": "키스페이스 이름",
      "keyspaceTooltip": "기존 키스페이스를 선택하거나 새 키스페이스 ID를 입력하세요.",
      "tableIdLabel": "테이블을 만들려면 CQL 명령을 입력하세요.",
      "enterTableId": "테이블 ID 입력",
      "tableSchemaAriaLabel": "테이블 스키마",
      "provisionDedicatedThroughput": "이 테이블에 대한 전용 처리량 프로비전",
      "provisionDedicatedThroughputTooltip": "키스페이스에 처리량이 프로비전된 경우, 테이블에 전용 처리량을 선택적으로 프로비전할 수 있습니다. 이 전용 처리량은 키스페이스 내 다른 테이블과 공유되지 않으며, 키스페이스에 프로비전한 처리량에 포함되지 않습니다. 이 전용 처리량은 키스페이스 수준에서 프로비전한 처리량과 별도로 청구됩니다."
    },
    "tables": {
      "addProperty": "속성 추가",
      "addRow": "행 추가",
      "addEntity": "엔터티 추가",
      "back": "뒤로",
      "nullFieldsWarning": "경고: Null 필드는 편집용으로 표시되지 않습니다.",
      "propertyEmptyError": "{{property}}을(를) 비워 둘 수 없습니다. {{property}} 값을 입력하세요.",
      "whitespaceError": "{{property}}에 공백을 포함할 수 없습니다. {{property}}에 공백 없이 값을 입력하세요.",
      "propertyTypeEmptyError": "속성 형식은 비워 둘 수 없습니다. 속성 {{property}}에 대한 드롭다운에서 형식을 선택하세요."
    },
    "tableQuerySelect": {
      "selectColumns": "쿼리할 열을 선택하세요.",
      "availableColumns": "사용 가능한 열"
    },
    "tableColumnSelection": {
      "selectColumns": "컨테이너 항목 보기에서 표시할 열을 선택하세요.",
      "searchFields": "검색 필드",
      "reset": "다시 설정",
      "partitionKeySuffix": " (파티션 키)"
    },
    "newVertex": {
      "addProperty": "속성 추가"
    },
    "addGlobalSecondaryIndex": {
      "globalSecondaryIndexId": "전역 보조 인덱스 컨테이너 ID",
      "globalSecondaryIndexIdPlaceholder": "e.g., indexbyEmailId",
      "projectionQuery": "프로젝션 쿼리",
      "projectionQueryPlaceholder": "SELECT c.email, c.accountId FROM c",
      "projectionQueryTooltip": "전역 보조 인덱스 정의에 대해 자세히 알아보세요.",
      "disabledTitle": "전역 보조 인덱스가 이미 생성 중입니다. 다른 항목을 만들기 전에 완료되기를 기다려 주세요."
    },
    "stringInput": {
      "inputMismatchError": "입력한 {{input}}이(가) 선택한 {{selectedId}}와(과) 일치하지 않습니다."
    },
    "panelInfo": {
      "information": "정보",
      "moreDetails": "추가 세부 정보"
    }
  },
  "controls": {
    "settings": {
      "tabTitles": {
        "scale": "Scale",
        "conflictResolution": "Conflict Resolution",
        "settings": "Settings",
        "indexingPolicy": "Indexing Policy",
        "partitionKeys": "Partition Keys",
        "partitionKeysPreview": "Partition Keys (preview)",
        "computedProperties": "Computed Properties",
        "containerPolicies": "Container Policies",
        "throughputBuckets": "Throughput Buckets",
        "globalSecondaryIndexPreview": "Global Secondary Index (Preview)",
        "maskingPolicyPreview": "Masking Policy (preview)"
      },
      "mongoNotifications": {
        "selectTypeWarning": "Please select a type for each index.",
        "enterFieldNameError": "Please enter a field name.",
        "wildcardPathError": "Wildcard path is not present in the field name. Use a pattern like "
      },
      "partitionKey": {
        "shardKey": "Shard key",
        "partitionKey": "Partition key",
        "shardKeyTooltip": "샤드 키(필드)는 데이터를 여러 복제본 집합(샤드)에 분산해 무제한 확장성을 제공합니다. 데이터를 고르게 분산할 필드를 신중히 선택하는 것이 중요합니다.",
        "partitionKeyTooltip": "is used to automatically distribute data across partitions for scalability. Choose a property in your JSON document that has a wide range of values and evenly distributes request volume.",
        "sqlPartitionKeyTooltipSuffix": " 읽기 작업이 적거나 쓰기 작업이 많은 모든 크기의 워크로드에는 id가 좋은 선택입니다.",
        "partitionKeySubtext": "For small workloads, the item ID is a suitable choice for the partition key.",
        "mongoPlaceholder": "e.g., categoryId",
        "gremlinPlaceholder": "e.g., /address",
        "sqlFirstPartitionKey": "필수 - 첫 번째 파티션 키(예: /TenantId)",
        "sqlSecondPartitionKey": "두 번째 파티션 키(예: /UserId)",
        "sqlThirdPartitionKey": "세 번째 파티션 키(예: /SessionId)",
        "defaultPlaceholder": "e.g., /address/zipCode"
      },
      "costEstimate": {
        "title": "Cost estimate*",
        "howWeCalculate": "How we calculate this",
        "updatedCostPerMonth": "Updated cost per month",
        "currentCostPerMonth": "Current cost per month",
        "perRu": "/RU",
        "perHour": "/hr",
        "perDay": "/day",
        "perMonth": "/mo"
      },
      "throughput": {
        "manualToAutoscaleDisclaimer": "The starting autoscale max RU/s will be determined by the system, based on the current manual throughput settings and storage of your resource. After autoscale has been enabled, you can change the max RU/s.",
        "ttlWarningText": "The system will automatically delete items based on the TTL value (in seconds) you provide, without needing a delete operation explicitly issued by a client application. For more information see,",
        "ttlWarningLinkText": "Time to Live (TTL) in Azure Cosmos DB",
        "unsavedIndexingPolicy": "indexing policy",
        "unsavedDataMaskingPolicy": "data masking policy",
        "unsavedComputedProperties": "computed properties",
        "unsavedEditorWarningPrefix": "You have not saved the latest changes made to your",
        "unsavedEditorWarningSuffix": ". Please click save to confirm the changes.",
        "updateDelayedApplyWarning": "You are about to request an increase in throughput beyond the pre-allocated capacity. This operation will take some time to complete.",
        "scalingUpDelayMessage": "Scaling up will take 4-6 hours as it exceeds what Azure Cosmos DB can instantly support currently based on your number of physical partitions. You can increase your throughput to {{instantMaximumThroughput}} instantly or proceed with this value and wait until the scale-up is completed.",
        "exceedPreAllocatedMessage": "Your request to increase throughput exceeds the pre-allocated capacity which may take longer than expected. There are three options you can choose from to proceed:",
        "instantScaleOption": "You can instantly scale up to {{instantMaximumThroughput}} RU/s.",
        "asyncScaleOption": "You can asynchronously scale up to any value under {{maximumThroughput}} RU/s in 4-6 hours.",
        "quotaMaxOption": "Your current quota max is {{maximumThroughput}} RU/s. To go over this limit, you must request a quota increase and the Azure Cosmos DB team will review.",
        "belowMinimumMessage": "You are not able to lower throughput below your current minimum of {{minimum}} RU/s. For more information on this limit, please refer to our service quote documentation.",
        "saveThroughputWarning": "Your bill will be affected as you update your throughput settings. Please review the updated cost estimate below before saving your changes",
        "currentAutoscaleThroughput": "Current autoscale throughput:",
        "targetAutoscaleThroughput": "Target autoscale throughput:",
        "currentManualThroughput": "Current manual throughput:",
        "targetManualThroughput": "Target manual throughput:",
        "applyDelayedMessage": "The request to increase the throughput has successfully been submitted. This operation will take 1-3 business days to complete. View the latest status in Notifications.",
        "databaseLabel": "Database:",
        "containerLabel": "Container:",
        "applyShortDelayMessage": "A request to increase the throughput is currently in progress. This operation will take some time to complete.",
        "applyLongDelayMessage": "A request to increase the throughput is currently in progress. This operation will take 1-3 business days to complete. View the latest status in Notifications.",
        "throughputCapError": "Your account is currently configured with a total throughput limit of {{throughputCap}} RU/s. This update isn't possible because it would increase the total throughput to {{newTotalThroughput}} RU/s. Change total throughput limit in cost management.",
        "throughputIncrementError": "Throughput value must be in increments of 1000"
      },
      "conflictResolution": {
        "lwwDefault": "Last Write Wins (default)",
        "customMergeProcedure": "Merge Procedure (custom)",
        "mode": "Mode",
        "conflictResolverProperty": "Conflict Resolver Property",
        "storedProcedure": "Stored procedure",
        "lwwTooltip": "Gets or sets the name of a integer property in your documents which is used for the Last Write Wins (LWW) based conflict resolution scheme. By default, the system uses the system defined timestamp property, _ts to decide the winner for the conflicting versions of the document. Specify your own integer property if you want to override the default timestamp based conflict resolution.",
        "customTooltip": "Gets or sets the name of a stored procedure (aka merge procedure) for resolving the conflicts. You can write application defined logic to determine the winner of the conflicting versions of a document. The stored procedure will get executed transactionally, exactly once, on the server side. If you do not provide a stored procedure, the conflicts will be populated in the",
        "customTooltipConflictsFeed": " conflicts feed",
        "customTooltipSuffix": ". You can update/re-register the stored procedure at any time."
      },
      "changeFeed": {
        "label": "Change feed log retention policy",
        "tooltip": "Enable change feed log retention policy to retain last 10 minutes of history for items in the container by default. To support this, the request unit (RU) charge for this container will be multiplied by a factor of two for writes. Reads are unaffected."
      },
      "mongoIndexing": {
        "disclaimer": "For queries that filter on multiple properties, create multiple single field indexes instead of a compound index.",
        "disclaimerCompoundIndexesLink": " Compound indexes ",
        "disclaimerSuffix": "are only used for sorting query results. If you need to add a compound index, you can create one using the Mongo shell.",
        "compoundNotSupported": "Collections with compound indexes are not yet supported in the indexing editor. To modify indexing policy for this collection, use the Mongo Shell.",
        "aadError": "To use the indexing policy editor, please login to the",
        "aadErrorLink": "azure portal.",
        "refreshingProgress": "Refreshing index transformation progress",
        "canMakeMoreChangesZero": "You can make more indexing changes once the current index transformation is complete. ",
        "refreshToCheck": "Refresh to check if it has completed.",
        "canMakeMoreChangesProgress": "You can make more indexing changes once the current index transformation has completed. It is {{progress}}% complete. ",
        "refreshToCheckProgress": "Refresh to check the progress.",
        "definitionColumn": "Definition",
        "typeColumn": "Type",
        "dropIndexColumn": "Drop Index",
        "addIndexBackColumn": "Add index back",
        "deleteIndexButton": "Delete index Button",
        "addBackIndexButton": "Add back Index Button",
        "currentIndexes": "Current index(es)",
        "indexesToBeDropped": "Index(es) to be dropped",
        "indexFieldName": "Index Field Name",
        "indexType": "Index Type",
        "selectIndexType": "Select an index type",
        "undoButton": "Undo Button"
      },
      "subSettings": {
        "timeToLive": "Time to Live",
        "ttlOff": "Off",
        "ttlOnNoDefault": "On (no default)",
        "ttlOn": "On",
        "seconds": "second(s)",
        "timeToLiveInSeconds": "Time to live in seconds",
        "analyticalStorageTtl": "Analytical Storage Time to Live",
        "geospatialConfiguration": "Geospatial Configuration",
        "geography": "Geography",
        "geometry": "Geometry",
        "uniqueKeys": "Unique keys",
        "mongoTtlMessage": "To enable time-to-live (TTL) for your collection/documents,",
        "mongoTtlLinkText": "create a TTL index",
        "partitionKeyTooltipTemplate": "This {{partitionKeyName}} is used to distribute data across multiple partitions for scalability. The value \"{{partitionKeyValue}}\" determines how documents are partitioned.",
        "largePartitionKeyEnabled": "Large {{partitionKeyName}} has been enabled.",
        "hierarchicalPartitioned": "Hierarchically partitioned container.",
        "nonHierarchicalPartitioned": "Non-hierarchically partitioned container."
      },
      "scale": {
        "freeTierInfo": "With free tier, you will get the first {{ru}} RU/s and {{storage}} GB of storage in this account for free. To keep your account free, keep the total RU/s across all resources in the account to {{ru}} RU/s.",
        "freeTierLearnMore": "Learn more.",
        "throughputRuS": "Throughput (RU/s)",
        "autoScaleCustomSettings": "Your account has custom settings that prevents setting throughput at the container level. Please work with your Cosmos DB engineering team point of contact to make changes.",
        "keyspaceSharedThroughput": "This table shared throughput is configured at the keyspace",
        "throughputRangeLabel": "Throughput ({{min}} - {{max}} RU/s)",
        "unlimited": "unlimited"
      },
      "partitionKeyEditor": {
        "changePartitionKey": "Change {{partitionKeyName}}",
        "currentPartitionKey": "Current {{partitionKeyName}}",
        "partitioning": "Partitioning",
        "hierarchical": "Hierarchical",
        "nonHierarchical": "Non-hierarchical",
        "safeguardWarning": "To safeguard the integrity of the data being copied to the new container, ensure that no updates are made to the source container for the entire duration of the partition key change process.",
        "changeDescription": "To change the partition key, a new destination container must be created or an existing destination container selected. Data will then be copied to the destination container.",
        "changeButton": "Change",
        "changeJob": "{{partitionKeyName}} change job",
        "cancelButton": "Cancel",
        "documentsProcessed": "({{processedCount}} of {{totalCount}} documents processed)"
      },
      "computedProperties": {
        "ariaLabel": "Computed properties",
        "learnMorePrefix": "about how to define computed properties and how to use them."
      },
      "indexingPolicy": {
        "ariaLabel": "Indexing Policy"
      },
      "dataMasking": {
        "ariaLabel": "Data Masking Policy",
        "validationFailed": "Validation failed:",
        "includedPathsRequired": "includedPaths is required",
        "includedPathsMustBeArray": "includedPaths must be an array",
        "excludedPathsMustBeArray": "excludedPaths must be an array if provided"
      },
      "containerPolicy": {
        "vectorPolicy": "Vector Policy",
        "fullTextPolicy": "Full Text Policy",
        "createFullTextPolicy": "Create new full text search policy"
      },
      "globalSecondaryIndex": {
        "indexesDefined": "This container has the following indexes defined for it.",
        "learnMoreSuffix": "about how to define global secondary indexes and how to use them.",
        "jsonAriaLabel": "Global Secondary Index JSON",
        "addIndex": "Add index",
        "settingsTitle": "Global Secondary Index Settings",
        "sourceContainer": "Source container",
        "indexDefinition": "Global secondary index definition"
      },
      "indexingPolicyRefresh": {
        "refreshFailed": "Refreshing index transformation progress failed"
      },
      "throughputInput": {
        "autoscale": "Autoscale",
        "manual": "Manual",
        "minimumRuS": "Minimum RU/s",
        "maximumRuS": "Maximum RU/s",
        "x10Equals": "x 10 =",
        "storageCapacity": "Storage capacity",
        "fixed": "Fixed",
        "unlimited": "Unlimited",
        "instant": "Instant",
        "fourToSixHrs": "4-6 hrs",
        "autoscaleDescription": "Based on usage, your {{resourceType}} throughput will scale from",
        "freeTierWarning": "Billing will apply if you provision more than {{ru}} RU/s of manual throughput, or if the resource scales beyond {{ru}} RU/s with autoscale.",
        "capacityCalculator": "Estimate your required RU/s with",
        "capacityCalculatorLink": " capacity calculator",
        "fixedStorageNote": "When using a collection with fixed storage capacity, you can set up to 10,000 RU/s.",
        "min": "min",
        "max": "max"
      },
      "throughputBuckets": {
        "label": "Throughput Buckets",
        "bucketLabel": "Bucket {{id}}",
        "dataExplorerQueryBucket": " (Data Explorer Query Bucket)",
        "active": "Active",
        "inactive": "Inactive"
      }
    }
  }
}