node-red/packages/node_modules/@node-red/nodes/locales/ko/messages.json

{
    "common": {
        "label": {
            "payload": "페이로드",
            "topic": "토픽",
            "name": "이름",
            "username": "유저",
            "password": "패스워드",
            "property": "프로퍼티"
        },
        "status": {
            "connected": "접속됨",
            "not-connected": "미접속",
            "disconnected": "절단",
            "connecting": "접속중",
            "error": "에러",
            "ok": "OK"
        },
        "notification": {
            "error": "<strong>에러</strong>: __message__",
            "errors": {
                "not-deployed": "노드가 배포되지 않았습니다",
                "no-response": "서버의 응답이 없습니다",
                "unexpected": "예상치 못한 에러 (__status__) __message__"
            }
        },
        "errors": {
            "nooverride": "경고:메세지에서 설정한 프로퍼티는, 노드의 프로퍼티를 덮어쓸 수 없습니다.자세한 사항은 bit.ly/nr-override-msg-props를 참조해 주세요."
        }
    },
    "inject": {
        "inject": "inject",
        "repeat": "repeat = __repeat__",
        "crontab": "crontab = __crontab__",
        "stopped": "stopped",
        "failed": "inject실패: __error__",
        "label": {
            "repeat": "반복",
            "flow": "플로우 컨텍스트",
            "global": "글로벌 컨텍스트",
            "str": "문자열",
            "num": "수치",
            "bool": "진위값",
            "json": "오브젝트",
            "bin": "버퍼",
            "date": "타임스탬프",
            "env": "환경변수",
            "object": "오브젝트",
            "string": "문자열",
            "boolean": "진위값",
            "number": "수치",
            "Array": "배열",
            "invalid": "올바르지 않은 JSON"
        },
        "timestamp": "타임스탬프",
        "none": "없음",
        "interval": "지정한 시간간격",
        "interval-time": "지정한 시간간격, 일시",
        "time": "지정한 일시",
        "seconds": "초",
        "minutes": "분",
        "hours": "시간",
        "between": "시각",
        "previous": "이전의 값",
        "at": "시각",
        "and": "~",
        "every": "시간각격",
        "days": [
            "월요일",
            "화요일",
            "수요일",
            "목요일",
            "금요일",
            "토요일",
            "일요일"
        ],
        "on": "요일",
        "onstart": "Node-RED시작의",
        "onceDelay": "초 후, 아래를 시행",
        "tip": "<b>주석:</b> '지정한 시간간격, 일시'와 '지정한 일시'는 cron을 사용합니다. <br/>'시간간격'에는 596시간 보다 작은 값을 지정합니다.<br/>자세한 사항은 노드의 '정보'를 확인해 주세요.",
        "success": "inject처리를 실행했습니다: __label__",
        "errors": {
            "failed": "inject처리를 실패했습니다. 자세한사항은 로그를 확인해 주세요.",
            "toolong": "시간간격이 너무 큽니다."
        }
    },
    "catch": {
        "catch": "catch: 모두",
        "catchNodes": "catch: __number__",
        "catchUncaught": "catch: 미보충",
        "label": {
            "source": "에러 취득처",
            "selectAll": "모두 선택",
            "uncaught": "Catch노드로 처리된 에러를 무시"
        },
        "scope": {
            "all": "모든 노드",
            "selected": "선택한 노드"
        }
    },
    "status": {
        "status": "status: 모두",
        "statusNodes": "status: __number__",
        "label": {
            "source": "상태취득처",
            "sortByType": "타입순으로 정렬"
        },
        "scope": {
            "all": "모든 노드",
            "selected": "선택한 노드"
        }
    },
    "debug": {
        "output": "대상",
        "none": "없음",
        "invalid-exp": "JSONata식이 올바르지 않음: __error__",
        "msgprop": "메세지 프로퍼티",
        "msgobj": "msg오브젝트 전체",
        "to": "출력대상",
        "debtab": "디버그 탭",
        "tabcon": "디버그 탭과 콘솔",
        "toSidebar": "디버그 창",
        "toConsole": "시스템 콘솔",
        "toStatus": "노드 상태(32자)",
        "severity": "레벨",
        "notification": {
            "activated": "유효화 했습니다: __label__",
            "deactivated": "무효화 했습니다: __label__"
        },
        "sidebar": {
            "label": "디버그",
            "name": "디버그 메세지",
            "filterAll": "모든 플로우",
            "filterSelected": "선택한 노드",
            "filterCurrent": "현재의 플로우",
            "debugNodes": "debug노드",
            "clearLog": "로그를 삭제",
             "filterLog": "로그 필터링",
            "openWindow": "새 창에서 열기"
        },
        "messageMenu": {
            "collapseAll": "모든 패스 접기",
            "clearPinned": "선택한 패스",
            "filterNode": "노드를 필터",
            "clearFilter": "필터를 초기화"
        }
    },
    "link": {
        "linkIn": "link in",
        "linkOut": "link out"
    },
    "tls": {
        "tls": "TLS설정",
        "label": {
            "use-local-files": "로컬파일의 비밀키와 인증서를 사용",
            "upload": "파일",
            "cert": "인증서",
            "key": "비밀키",
            "passphrase": "패스 프레이즈",
            "ca": "CA인증서",
            "verify-server-cert": "서버인증서를 확인",
            "servername": "서버명"
        },
        "placeholder": {
            "cert": "인증서(PEM형식) 패스",
            "key": "비밀키(PEM형식) 패스",
            "ca": "CA인증서(PEM형식) 패스",
            "passphrase": "비밀키 패스프레이즈 (임의)",
            "servername": "SNI로 사용"
        },
        "error": {
            "missing-file": "인증서와 비밀키 파일이 설정되지 않았습니다"
        }
    },
    "exec": {
        "exec": "exec",
        "spawn": "spawn",
        "label": {
            "command": "커맨드",
            "append": "인수",
            "timeout": "타임아웃",
            "timeoutplace": "임의",
            "return": "출력",
            "seconds": "초",
            "stdout": "표준 출력",
            "stderr": "표준에러 출력",
            "retcode": "반환 코드"
        },
        "placeholder": {
            "extraparams": "추가 인수"
        },
        "opt": {
            "exec": "커맨드 종료시 - exec모드",
            "spawn": "커맨드 실행 중 - spawn모드"
        },
        "oldrc": "구 형식의 출력를 사용(호환 모드)"
    },
    "function": {
        "function": "",
        "label": {
            "function": "코드",
            "outputs": "출력 수"
        },
        "error": {
            "inputListener": "코드 내에서'input'이벤트의 리스터를 설정할 수 없습니다",
            "non-message-returned": "Function노드가 __type__ 타입의 메세지송신을 시도했습니다"
        }
    },
    "template": {
        "template": "template",
        "label": {
            "template": "템플릿",
            "property": "프로퍼티",
            "format": "구문",
            "syntax": "형식",
            "output": "출력형식",
            "mustache": "Mustache템플릿",
            "plain": "평분",
            "json": "JSON",
            "yaml": "YAML",
            "none": "없음"
        },
        "templatevalue": "This is the payload: {{payload}} !"
    },
    "delay": {
        "action": "동작",
        "for": "시간",
        "delaymsg": "메세지 지연",
        "delayfixed": "지정한 시간 지연",
        "delayvarmsg": "msg.delay에 지연을 설정",
        "randomdelay": "랜덤 지연",
        "limitrate": "메세지의 유량제한",
        "limitall": "모든 메세지",
        "limittopic": "msg.topic 마다",
        "fairqueue": "지정한 시간 후에 큐 선두의 토픽 메세지를 출력",
        "timedqueue": "지정한 시간 후에 큐에 있는 모든 토픽 메세지를 출력",
        "milisecs": "밀리초",
        "secs": "초",
        "sec": "초",
        "mins": "분",
        "min": "분",
        "hours": "시간",
        "hour": "시간",
        "days": "일",
        "day": "일",
        "between": "빈도",
        "and": "번／",
        "rate": "유량",
        "msgper": "메세지／",
        "dropmsg": "중간 메세지를 삭제",
        "label": {
            "delay": "delay",
            "variable": "variable",
            "limit": "limit",
            "limitTopic": "limit topic",
            "random": "random",
            "units": {
                "second": {
                    "plural": "초",
                    "singular": "초"
                },
                "minute": {
                    "plural": "분",
                    "singular": "분"
                },
                "hour": {
                    "plural": "시간",
                    "singular": "시간"
                },
                "day": {
                    "plural": "일",
                    "singular": "일"
                }
            }
        },
        "error": {
            "buffer": "버퍼 상한의 1000메세지를 넘었습니다",
            "buffer1": "버퍼 상한의 10000메세지를 넘었습니다"
        }
    },
    "trigger": {
        "send": "송신 데이터",
        "then": "송신후의 처리",
        "then-send": "재송신 데이터",
        "output": {
            "string": "문자열",
            "number": "수치",
            "existing": "존재하는 msg오브젝트",
            "original": "원래의 msg오브젝트",
            "latest": "최신 msg오브젝트",
            "nothing": "없음"
        },
        "wait-reset": "초기화될 때 까지 대기",
        "wait-for": "지정한 시간 대기",
        "wait-loop": "지정한 시간 간격마다 송신을 반복",
        "for": "처리대상",
        "bytopics": "msg.topic 마다",
        "alltopics": "모든 메세지",
        "duration": {
            "ms": "밀리초",
            "s": "초",
            "m": "분",
            "h": "시간"
        },
        "extend": "새로운 메세지를 받았을 때 지연을 연장",
        "label": {
            "trigger": "trigger",
            "trigger-block": "trigger & block",
            "trigger-loop": "resend every",
            "reset": "초기화 조건:",
            "resetMessage": "msg.reset을 설정",
            "resetPayload": "msg.payload가 다음 값",
            "resetprompt": "임의"
        }
    },
    "comment": {
        "comment": "comment"
    },
    "unknown": {
        "label": {
            "unknown": "unknown"
        },
        "tip": "<p>현재의 Node-RED환경에서는 이 노드의 타입을 알 수 없습니다.</p><p><i>현재의 상태에서 이 노드를 배포하면 설정은 보존되지만, 해당 노드가 설치될 때 까지 플로우는 실행되지 않습니다.</i></p><p>자세한 사항은 노드의 '정보'를 참조해 주세요.</p>"
    },
    "mqtt": {
        "label": {
            "broker": "서버",
            "example": "예) localhost",
            "output": "출력",
            "qos": "QoS",
            "retain": "보존",
            "clientid": "클라이언트",
            "port": "포트",
            "keepalive": "킵 얼라이브 시간",
            "cleansession": "세션 초기화",
            "use-tls": "SSL/TLS접속을 사용",
            "tls-config": "TLS설정",
            "verify-server-cert": "서버인증서를 확인",
            "compatmode": "구 MQTT 3.1서포트"
        },
        "sections-label": {
            "birth-message": "접속시의 송신메세지(Birth메세지)",
            "will-message": "예기치 않은 절단시의 송신메세지(Will메세지)",
            "close-message": "절단 전의 송신메세지(Close메세지)"
        },
        "tabs-label": {
            "connection": "접속",
            "security": "세큐리티",
            "messages": "메세지"
        },
        "placeholder": {
            "clientid": "ID를 자동생성하는 경우에는, 기입하지 않습니다",
            "clientid-nonclean": "신규가 아닌 세션을 설정해 주세요",
            "will-topic": "Will메세지를 무효화하는 경우에는, 기입하지 않습니다",
            "birth-topic": "Birth메세지를 무효화하는 경우에는, 기입하지 않습니다",
            "close-topic": "Close메세지를 무효화하는 경우에는, 기입하지 않습니다"
        },
        "state": {
            "connected": "브로커에 접속했습니다: __broker__",
            "disconnected": "브로커에서 절단되었습니다: __broker__",
            "connect-failed": "브로커에 접속에 실패했습니다: __broker__"
        },
        "retain": "보존",
        "output": {
            "buffer": "바이너리 버퍼",
            "string": "문자열",
            "base64": "Base64문자열",
            "auto": "자동판정(문자열혹은 바이너리버퍼)",
            "json": "JSON오브젝트"
        },
        "true": "한다",
        "false": "하지않는다",
        "tip": "주석: 토픽이나 QoS를 메세지의 프로퍼티를 사용하여 설정하는 경우에는, 기입하지 않습니다.",
        "errors": {
            "not-defined": "토픽이 설정되지 않았습니다",
            "missing-config": "브로커가 설정되지 않았습니다",
            "invalid-topic": "올바르지 않은 토픽이 설정되어 있습니다",
            "nonclean-missingclientid": "’세션 초기화’사용시에,클라이언트ID가 설정되지 않았습니다",
            "invalid-json-string": "올바르지 않은 JSON문자열",
            "invalid-json-parse": "JSON문자열의 퍼스에 실패했습니다"
        }
    },
    "httpin": {
        "label": {
            "method": "메소드",
            "url": "URL",
            "doc": "Docs",
            "return": "출력형식",
            "upload": "파일 업로드",
            "status": "상태코드",
            "headers": "헤더",
            "other": "그 외",
            "paytoqs" : "msg.payload를 쿼리 파라미터에 추가",
            "utf8String": "UTF8문자열",
            "binaryBuffer": "바이너리 버퍼",
            "jsonObject": "JSON오브젝트",
            "authType": "종류별",
            "bearerToken": "토큰"
        },
        "setby": "- msg.method에 정의 -",
        "basicauth": "인증을 사용",
        "use-tls": "SSL/TLS접속을 유효화",
        "tls-config": "TLS설정",
        "basic": "Basic인증",
        "digest": "Digest인증",
        "bearer": "Bearer인증",
        "use-proxy": "프록시를 사용",
        "proxy-config": "프록시 설정",
        "use-proxyauth": "프록시인증을 사용",
        "noproxy-hosts": "예외 호스트",
        "utf8": "UTF8문자열",
        "binary": "바이너리 버퍼",
        "json": "JSON오브젝트",
        "tip": {
            "in": "URL은 상대 패스가 됩니다.",
            "res": "이 노드에 보내지는 메세지는, <i>http input</i>노드를 기점으로 해 주세요.",
            "req": "주석: JSON의 구문해석에 실패한 경우에는, 취득한 문자열을 그대로 출력합니다."
        },
        "httpreq": "http request",
        "errors": {
            "not-created": "httpNodeRoot에 false가설정되었을 때에는,http-in노드를 작성할 수 없습니다",
            "missing-path": "패스가 설정되지 않았습니다",
            "no-response": "응답이 없습니다",
            "json-error": "JSON의 구분해석 에러",
            "no-url": "URL가 설정되지 않았습니다",
            "deprecated-call": "권장하지 않는 호출입니다 __method__",
            "invalid-transport": "http가 아닌 트랜스포트가 요구되었습니다",
            "timeout-isnan": "타임아웃값이 수치가 아니기 때문에 무시합니다",
            "timeout-isnegative": "타임아웃값이 음수이기 때문에 무시합니다",
            "invalid-payload": "올바르지 않은 페이로드"
        },
        "status": {
            "requesting": "요구중"
        }
    },
    "websocket": {
        "label": {
            "type": "종류",
            "path": "패스",
            "url": "URL"
        },
        "listenon": "대기",
        "connectto": "접속",
        "sendrec": "송신/수신",
        "payload": "페이로드를 송신/수신",
        "message": "메세지 전체를 송신/수신",
        "tip": {
            "path1": "표준으로는 <code>payload</code> 가 websocket에서 송신, 수신된 데이터를 기다립니다. 클라이언트는 JSON형식의 문자열로 메세지전체를 송신, 수신하도록 설정할 수 있습니다.",
            "path2": "This path will be relative to ",
            "url1": "URL에는 ws:&#47;&#47; 또는 wss:&#47;&#47; 스키마를 사용하여, 존재하는 websocket리스너를 설정해 주세요.",
            "url2": "표준으로는 <code>payload</code> 가 websocket에서 송신,수신될 데이터를 기다립니다.클라이언트는 JSON형식의 문자열로 메세지전체를 송신, 수신하도록 설정할 수 있습니다."
        },
        "status": {
            "connected": "접속 수 __count__",
            "connected_plural": "접속 수 __count__"
        },
        "errors": {
            "connect-error": "ws접속에서 에러가 발생했습니다: ",
            "send-error": "송신중 에러가 발생했습니다: ",
            "missing-conf": "서버설정이 부족합니다",
            "duplicate-path": "같은 패스에 대해 2개의 WebSocket리스너는 지정할 수 없습니다: __path__"
        }
    },
    "watch": {
        "watch": "watch",
        "label": {
            "files": "파일",
            "recursive": "서브디렉토리를 재귀적으로 감시"
        },
        "placeholder": {
            "files": "복수의 파일이나 디렉토리는 콤마로 나누어 입력"
        },
        "tip": "Windows인 경우, 디렉토리를 나누는 문자로 2개의 백슬래쉬 \\\\ 를 사용해 주세요."
    },
    "tcpin": {
        "label": {
            "type": "종류",
            "output": "출력",
            "port": "포트",
            "host": "호스트",
            "payload": "의 페이로드",
            "delimited": "나누는 문자",
            "close-connection": "메세지를 송신할 때마다 접속을 절단",
            "decode-base64": "Base64메세지의 복호",
            "server": "서버",
            "return": "반환값",
            "ms": "밀리초",
            "chars": "문자"
        },
        "type": {
            "listen": "대기",
            "connect": "접속",
            "reply": "TCP응답"
        },
        "output": {
            "stream": "스트림",
            "single": "단일",
            "buffer": "바이너리 버퍼",
            "string": "문자열",
            "base64": "Base64문자열"
        },
        "return": {
            "timeout": "지정시간 후",
            "character": "지정문자의 수신時",
            "number": "지정 개수의 문자열",
            "never": "없음 - 접속을 유지",
            "immed": "즉시 - 응답을 기다리지 않음"
        },
        "status": {
            "connecting": "__host__:__port__ 에 접속하고 있습니다",
            "connected": "__host__:__port__ 에 접속했습니다",
            "listening-port": "포트 __port__ 에서 접속을 기다리고 있습니다",
            "stopped-listening": "포트의 대기를 정지했습니다",
            "connection-from": "__host__:__port__ 에서 접속되었습니다",
            "connection-closed": "__host__:__port__ 에서의 접속이 절단되었습니다",
            "connections": "접속 수 __count__",
            "connections_plural": "접속 수 __count__"
        },
        "errors": {
            "connection-lost": "__host__:__port__ 으로의 접속이 소실되었습니다",
            "timeout": "포트 __port__ 의 소켓이 타임아웃에 의해 절단되었습니다",
            "cannot-listen": "포트 __port__ 의 대기를 할 수 없습니다 에러: __error__",
            "error": "에러: __error__",
            "socket-error": "__host__:__port__ 에서 소켓의 에러가 발생했습니다",
            "no-host": "호스트명 혹은 포트가 설정되지 않았습니다",
            "connect-timeout": "접속이 타임아웃 됐습니다",
            "connect-fail": "접속에 실패했습니다"
        }
    },
    "udp": {
        "label": {
            "listen": "대기",
            "onport": "포트",
            "using": "종류",
            "output": "출력",
            "group": "그룹",
            "interface": "로컬IP",
            "send": "송신",
            "toport": "포트",
            "address": "어드레스",
            "decode-base64": "Base64형식의 페이로드를 복호"
        },
        "placeholder": {
            "interface": "(임의) 사용할 로컬인터페이스 혹은 어드레스",
            "interfaceprompt": "(임의) 사용할 로컬인터페이스 혹은 어드레스",
            "address": "수신IP어드레스"
        },
        "udpmsgs": "UDP메세지",
        "mcmsgs": "멀티캐스트 메세지",
        "udpmsg": "UDP메세지",
        "bcmsg": "브로드캐스트 메세지",
        "mcmsg": "멀티캐스트 메세지",
        "output": {
            "buffer": "바이너리 버퍼",
            "string": "문자열",
            "base64": "Base64문자열"
        },
        "bind": {
            "random": "로컬포트를 랜덤하게 사용",
            "local": "로컬포트를 사용",
            "target": "지정한포트를 사용"
        },
        "tip": {
            "in": "주석: 방화벽이 통신을 허가하고 있는지 확인해 주세요.",
            "out": "주석: <code>msg.ip</code>나 <code>msg.port</code> 를 사용하여 설정하는 경우에는,’어드레스’나 ’포트’를 기입하지 않습니다.",
            "port": "이미 포트가 사용중 입니다: "
        },
        "status": {
            "listener-at": "udp노드가 __host__:__port__ 에서 접속을 기다리고 있습니다",
            "mc-group": "udp노드가 그룹 __group__ 에 멀티캐스트 했습니다",
            "listener-stopped": "udp노드가 대기를 정지했습니다",
            "output-stopped": "udp노드가 출력을 정지했습니다",
            "mc-ready": "udp노드는 멀티캐스트 준비가 끝났습니다: __iface__:__outport__ -> __host__:__port__",
            "bc-ready": "udp노드는 브로드캐스트 준비가 끝났습니다: __outport__ -> __host__:__port__",
            "ready": "udp노드는 준비되었습니다: __outport__ -> __host__:__port__",
            "ready-nolocal": "udp노드는 준비되었습니다: __host__:__port__",
            "re-use": "udp재이용 소켓: __outport__ -> __host__:__port__"
        },
        "errors": {
            "access-error": "UDP접속에러 관리자 권한으로 1024미만의 포트번호에 액세스할 필요가 있습니다",
            "error": "에러: __error__",
            "bad-mcaddress": "멀티캐스트어드레스가 올바르지 않습니다",
            "interface": "인터페이스의 IP어드레스를 설정할 필요가 있습니다 ",
            "ip-notset": "udp: IP어드레스가 설정되지 않았습니다",
            "port-notset": "udp: 포트가 설정되지 않았습니다",
            "port-invalid": "udp: 포트번호가 올바르지 않습니다",
            "alreadyused": "udp: 이미 __port__번 포트가 사용중 입니다",
            "ifnotfound": "udp: 인터페이스 __iface__ 가 없습니다"
        }
    },
    "switch": {
        "switch": "switch",
        "label": {
            "property": "프로퍼티",
            "rule": "조건",
            "repair": "메세지열의 보정"
        },
        "and": "～",
        "checkall": "모든 조건을 적용",
        "stopfirst": "처음 맞은 조건으로 종료",
        "ignorecase": "대문자, 소문자를 구별하지 않음",
        "rules": {
            "btwn": "is between",
            "cont": "contains",
            "regex": "matches regex",
            "true": "is true",
            "false": "is false",
            "null": "is null",
            "nnull": "is not null",
            "istype": "is of type",
            "empty": "is empty",
            "nempty": "is not empty",
            "head": "head",
            "tail": "tail",
            "index": "index between",
            "exp": "JSONata식",
            "else": "그 외"
        },
        "errors": {
            "invalid-expr": "올바르지 않은 표현: __error__",
            "too-many": "switch노드 내에서 보존하고 있는 메세지가 너무 많습니다"
        }
    },
    "change": {
        "label": {
            "rules": "룰",
            "rule": "룰",
            "set": "set __property__",
            "change": "change __property__",
            "delete": "delete __property__",
            "move": "move __property__",
            "changeCount": "change: __count__ rules",
            "regex": "정규표현를 사용"
        },
        "action": {
            "set": "값의 대입",
            "change": "값의 치환",
            "delete": "값의 삭제",
            "move": "값의 이동",
            "to": "대상의 값",
            "search": "검색할 문자열",
            "replace": "치환 후의 문자열"
        },
        "errors": {
            "invalid-from": "조작대상의 프로퍼티가 올바르지 않음: __error__",
            "invalid-json": "대상 값의 JSON프로퍼티가 올바르지 않음",
            "invalid-expr": "JSONata식이 올바르지 않음: __error__"
        }
    },
    "range": {
        "range": "range",
        "label": {
            "action": "동작",
            "inputrange": "입력값의 범위",
            "resultrange": "출력값의 범위",
            "from": "최소값",
            "to": "최대값",
            "roundresult": "작은 수치를 반올림하여 정수치로 변환"
        },
        "placeholder": {
            "min": "예) 0",
            "maxin": "예) 99",
            "maxout": "예) 255"
        },
        "scale": {
            "payload": "msg.payload의 값을 확대/축소",
            "limit": "입력값의 범위외의 값을 최소값/최대값으로 해서 확대/축소",
            "wrap": "입력값의 범위외의 값을 범위폭으로 나눈 나머지로 해서 확대/축소"
        },
        "tip": "주석: 이 노드는, 수치만 다룰 수 있습니다.",
        "errors": {
            "notnumber": "수치가 아닙니다"
        }
    },
    "csv": {
        "label": {
            "columns": "열 이름",
            "separator": "나누는 문자",
            "c2o": "CSV에서 오브젝트로 변환",
            "o2c": "오브젝트에서 CSV로 변환",
            "input": "입력",
            "skip-s": "처음의",
            "skip-e": "행을 무시한다",
            "firstrow": "첫번째 행에 열 이름을 포함",
            "output": "출력",
            "includerow": "첫번째 행을 열 이름으로 함",
            "newline": "줄바꿈 코드"
        },
        "placeholder": {
            "columns": "콤마로 나누어 열 이름을 입력"
        },
        "separator": {
            "comma": "콤마",
            "tab": "탭",
            "space": "공백",
            "semicolon": "세미콜론",
            "colon": "콜론",
            "hashtag": "해쉬태그",
            "other": "그 외..."
        },
        "output": {
            "row": "행마다 메세지를 분할",
            "array": "배열화 한 1개의 메세지"
        },
        "newline": {
            "linux": "Linux (\\n)",
            "mac": "Mac (\\r)",
            "windows": "Windows (\\r\\n)"
        },
        "errors": {
            "csv_js": "이 노드가 처리할 수 있는 형식은, CSV문자열 혹은 JSON뿐 입니다",
            "obj_csv": "오브젝트를 CSV로 변환할 때의 열 이름이 설정되지 않았습니다"
        }
    },
    "html": {
        "label": {
            "select": "추출할 요소",
            "output": "출력",
            "in": "대상:"
        },
        "output": {
            "html": "요소 내의 HTML",
            "text": "요소의 텍스트만",
            "attr": "요소의 모든 속성"
        },
        "format": {
            "single": "배열화 한 1개의 메세지",
            "multi": "요소마다의 복수의 메세지"
        }
    },
    "json": {
        "errors": {
            "dropped-object": "오브젝트형식이 아닌 페이로드를 무시했습니다",
            "dropped": "대응하지 않는 형식의 페이로드를 무시했습니다",
            "dropped-error": "페이로드의 변환처리가 실패했습니다",
            "schema-error": "JSON스키마 에러",
            "schema-error-compile": "JSON스키마에러: 스키마의 컴파일에 실패했습니다"
        },
        "label": {
            "o2j": "오브젝트에서 JSON로 변환",
            "pretty": "JSON문자열 형식",
            "action": "동작",
            "property": "프로퍼티",
            "actions": {
                "toggle": "JSON문자열과 오브젝트간의 상호변환",
                "str": "항상 JSON문자열로 변환",
                "obj": "항상 JavaScript오브젝트로 변환"
            }
        }
    },
    "yaml": {
        "errors": {
            "dropped-object": "오브젝트형식이 아닌 페이로드를 무시했습니다",
            "dropped": "대응하지 않는 형식의 페이로드를 무시했습니다",
            "dropped-error": "페이로드의 변환처리에 실패했습니다"
        }
    },
    "xml": {
        "label": {
            "represent": "XML태그속성을 다음 프로퍼티명으로 표현",
            "prefix": "문자열를 참조하기 위한 접두사",
            "advanced": "상세설정",
            "x2o": "XML에서 오브젝트로 변환"
        },
        "errors": {
            "xml_js": "이 노드는, XML형식의 문자열 혹은 JSON만 처리합니다"
        }
    },
    "file": {
        "label": {
            "filename": "파일명",
            "action": "동작",
            "addnewline": "메세지의 입력마다 줄바꿈을 추가",
            "createdir": "디렉토리가 존재하지 않는 경우에 작성",
            "outputas": "출력형식",
            "breakchunks": "청크로 분할",
            "breaklines": "행으로 분할",
            "filelabel": "file",
            "sendError": "에러메세지를 송신(호환모드)",
            "deletelabel": "delete __file__",
            "utf8String": "UTF8문자열",
            "binaryBuffer": "바이너리 버퍼"
        },
        "action": {
            "append": "파일에 추가",
            "overwrite": "파일을 덮어쓰기",
            "delete": "파일을 삭제"
        },
        "output": {
            "utf8": "문자열",
            "buffer": "바이너리 버퍼",
            "lines": "행 마다의 메세지",
            "stream": "버퍼의 스트림"
        },
        "status": {
            "wrotefile": "파일에 작성했습니다: __file__",
            "deletedfile": "파일을 삭제했습니다: __file__",
            "appendedfile": "파일에 추가했습니다: __file__"
        },
        "encoding": {
            "none": "기본값",
            "native": "네이티브",
            "unicode": "UNICODE",
            "japanese": "일본",
            "chinese": "중국",
            "korean": "한국",
            "taiwan": "대만/홍콩",
            "windows": "Windows코드 페이지",
            "iso": "ISO코드 페이지",
            "ibm": "IBM코드 페이지",
            "mac": "Mac코드 페이지",
            "koi8": "KOI8코드 페이지",
            "misc": "그 외"
        },
        "errors": {
            "nofilename": "파일명이 설정되지 않았습니다",
            "invaliddelete": "경고: 삭제가 무효합니다. 설정 다이얼로그에서 특정 삭제설정을 사용해 주세요",
            "deletefail": "파일의 삭제처리에 실패했습니다: __error__",
            "writefail": "파일의 작성처리에 실패했습니다: __error__",
            "appendfail": "파일의 추가처리에 실패했습니다: __error__",
            "createfail": "파일의 작성처리에 실패했습니다: __error__"
        },
        "tip": "주석: ’파일명’에 풀패스를 설정하지 않는 경우에는, Node-RED프로세스 실행디렉토리에서의 상대패스가 됩니다."
    },
    "split": {
        "split": "split",
        "intro": "타입에 따라 <code>msg.payload</code> 를 분할:",
        "object": "<b>오브젝트</b>",
        "objectSend": "각 key/value쌍의 메세지를 송신",
        "strBuff": "<b>문자열</b> / <b>버퍼</b>",
        "array": "<b>배열</b>",
        "splitUsing": "분할",
        "splitLength": "고정장",
        "stream": "메세지의 스트림로써 처리",
        "addname": " key의 복사처"
    },
    "join": {
        "join": "join",
        "mode": {
            "mode": "동작",
            "auto": "자동",
            "merge": "열의 결합",
            "reduce": "열의 집약",
            "custom": "수동"
        },
        "combine": "결합",
        "create": "출력",
        "type": {
            "string": "문자열",
            "array": "배열",
            "buffer": "버퍼",
            "object": "key/value오브젝트",
            "merged": "결합 오브젝트"
        },
        "using": "사용할 값",
        "key": "를 키로써 사용",
        "joinedUsing": "連結문자",
        "send": "메세지송신:",
        "afterCount": "지정수의 메세지파트를 수신 후",
        "count": "합계값",
        "subsequent": "후속 메세지마다",
        "afterTimeout": "첫 메세지수신부터 타임아웃 후",
        "seconds": "초",
        "complete": "<code>msg.complete</code> 프로퍼티가 설정된 메세지수신 후",
        "tip": "해당 모드에서는, 이 노드가 <i>split</i> 노드와 짝이 되거나, <code>msg.parts</code> 프로퍼티가 설정된 메세지를 수신하는 것을 전제로 합니다.",
        "too-many": "join노드내부에서 보존하고 있는 메세지가 너무 많습니다",
        "merge": {
            "topics-label": "대상토픽",
            "topics": "토픽",
            "topic": "토픽",
            "on-change": "신규토픽을 받으면 메세지를 송신한다"
        },
        "reduce": {
            "exp": "집약식",
            "exp-value": "식",
            "init": "초기값",
            "right": "평가를 역순으로 행함 (마지막에서 처음으로)",
            "fixup": "최종조정식"
        },
        "errors": {
            "invalid-expr": "JSONata식이 올바르지 않음: __error__"
        }
    },
    "sort": {
        "sort": "sort",
        "target": "대상",
        "seq": "메세지열",
        "key": "키",
        "elem": "요소의 값",
        "order": "순서",
        "ascending": "오름차순",
        "descending": "내림차순",
        "as-number": "수치로써 비교",
        "invalid-exp": "sort노드에서 올바르지 않은 JSONata식이 지정되었습니다: __message__",
        "too-many": "sort노드의 처리되지 않은 메세지 수가 허용수를 넘었습니다",
        "clear": "sort노드의 처리되지 않는 메세지를 파기했습니다"
    },
    "batch": {
        "batch": "batch",
        "mode": {
            "label": "모드",
            "num-msgs": "메세지수로 그룹화",
            "interval": "시간간격으로 그룹화",
            "concat": "열의 결합"
        },
        "count": {
            "label": "메세지수",
            "overlap": "오버랩",
            "count": "수",
            "invalid": "메세지수와 오버랩수가 올바르지 않음"
        },
        "interval": {
            "label": "시간간격",
            "seconds": "초",
            "empty": "메세지를 수신하지 않는 경우, 빈 메세지를 송신"
        },
        "concat": {
            "topics-label": "토픽",
            "topic": "토픽"
        },
        "too-many": "batch노드 내에서 보존하고 있는 메세지가 너무 많습니다",
        "unexpected": "상정할 수 없는 모드",
        "no-parts": "메세지에 parts프로퍼티가 없습니다"
    }
}