@rscc/common-core 0.1.2 → 0.3.0

package/dist/index.cjs

@@ -22,36 +22,71 @@ var index_exports = {};
 __export(index_exports, {
   ApiError: () => ApiError,
   BulkheadFullError: () => BulkheadFullError,
+  CircuitOpenError: () => CircuitOpenError,
   ResultCode: () => ResultCode,
+  WEBHOOK_SIGNATURE_HEADER: () => WEBHOOK_SIGNATURE_HEADER,
+  abbreviateAmount: () => abbreviateAmount,
+  ageByYear: () => ageByYear,
+  ageInsurance: () => ageInsurance,
+  ageMan: () => ageMan,
+  attachJosa: () => attachJosa,
+  buildListQuery: () => buildListQuery,
+  bulkFailures: () => bulkFailures,
+  classifyPhoneNumber: () => classifyPhoneNumber,
+  composeHangul: () => composeHangul,
   createApiClient: () => createApiClient,
+  createBulkResultBuilder: () => createBulkResultBuilder,
   createBulkhead: () => createBulkhead,
+  createBusinessDays: () => createBusinessDays,
   createCircuitBreaker: () => createCircuitBreaker,
+  createFeatureFlags: () => createFeatureFlags,
   createTokenBucket: () => createTokenBucket,
   createTtlCache: () => createTtlCache,
   decodeJwtPayload: () => decodeJwtPayload,
+  decomposeHangul: () => decomposeHangul,
+  formatPhoneNumber: () => formatPhoneNumber,
+  generateIdempotencyKey: () => generateIdempotencyKey,
   getTokenExpiry: () => getTokenExpiry,
+  isBulkResult: () => isBulkResult,
   isChosungQuery: () => isChosungQuery,
+  isForeignerRrn: () => isForeignerRrn,
   isRetryableStatus: () => isRetryableStatus,
   isTokenExpired: () => isTokenExpired,
   isValidBusinessNumber: () => isValidBusinessNumber,
   isValidCorporateNumber: () => isValidCorporateNumber,
+  isValidRrn: () => isValidRrn,
   isValidationErrorData: () => isValidationErrorData,
+  kindsForExtension: () => kindsForExtension,
   maskCardNumber: () => maskCardNumber,
   maskEmail: () => maskEmail,
   maskName: () => maskName,
   maskPhone: () => maskPhone,
   maskSecret: () => maskSecret,
+  matchesHangul: () => matchesHangul,
   normalizeBusinessNumber: () => normalizeBusinessNumber,
+  normalizePhoneNumber: () => normalizePhoneNumber,
+  normalizeRrn: () => normalizeRrn,
+  parseFlag: () => parseFlag,
   parseRetryAfterMs: () => parseRetryAfterMs,
   parseSseFrame: () => parseSseFrame,
   parseWireDateTime: () => parseWireDateTime,
+  pickJosa: () => pickJosa,
   readSseStream: () => readSseStream,
   retry: () => retry,
+  rrnBirthDate: () => rrnBirthDate,
+  rrnChecksumOkLegacy: () => rrnChecksumOkLegacy,
   sanitizeLogValue: () => sanitizeLogValue,
+  signWebhook: () => signWebhook,
+  sniffFile: () => sniffFile,
   stripZone: () => stripZone,
   toChosung: () => toChosung,
+  toE164: () => toE164,
+  toFormalNotation: () => toFormalNotation,
+  toKoreanWords: () => toKoreanWords,
   toWireDate: () => toWireDate,
-  toWireDateTime: () => toWireDateTime
+  toWireDateTime: () => toWireDateTime,
+  validateUpload: () => validateUpload,
+  verifyWebhook: () => verifyWebhook
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -77,6 +112,18 @@ var ResultCode = {
   INTERNAL_SERVER_ERROR: "500"
 };
 
+// src/idempotency.ts
+var FALLBACK_GROUPS = [8, 4, 4, 4, 12];
+function generateIdempotencyKey() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  return FALLBACK_GROUPS.map((len) => {
+    let group = "";
+    for (let i = 0; i < len; i++) group += Math.floor(Math.random() * 16).toString(16);
+    return group;
+  }).join("-");
+}
+
 // src/retry.ts
 var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
 function isRetryableStatus(status) {
@@ -170,6 +217,7 @@ var ApiError = class extends Error {
   }
 };
 var DEFAULT_RETRY_METHODS = ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"];
+var DEFAULT_IDEMPOTENCY_METHODS = ["POST", "PATCH"];
 var MAX_RAW_TEXT_LENGTH = 2048;
 function joinUrl(baseUrl, path) {
   if (path === "") return baseUrl;
@@ -207,11 +255,15 @@ function createApiClient(config) {
   async function requestWithMeta(path, init = {}) {
     const sentTraceId = generateTraceId();
     const method = (init.method ?? "GET").toUpperCase();
+    const idempotencyHeader = config.idempotency?.header ?? "Idempotency-Key";
+    const idempotencyKey = config.idempotency && (config.idempotency.methods ?? DEFAULT_IDEMPOTENCY_METHODS).includes(method) ? generateIdempotencyKey() : null;
     const attemptOnce = async () => {
       const headers = new Headers(init.headers);
       headers.set(traceIdHeader, sentTraceId);
-      const isFormData = typeof FormData !== "undefined" && init.body instanceof FormData;
-      if (!headers.has("Content-Type") && !isFormData) {
+      if (idempotencyKey !== null && !headers.has(idempotencyHeader)) {
+        headers.set(idempotencyHeader, idempotencyKey);
+      }
+      if (!headers.has("Content-Type") && typeof init.body === "string") {
         headers.set("Content-Type", "application/json");
       }
       if (config.getToken && !headers.has("Authorization")) {
@@ -276,8 +328,8 @@ function createApiClient(config) {
         return { data: json.data ?? void 0, traceId, status: response.status, response };
       }
       if (!response.ok) {
-        const j = json;
-        const message = typeof j?.message === "string" && j.message || typeof j?.error === "string" && j.error || `API \uC624\uB958: ${response.status} ${response.statusText}`;
+        const j2 = json;
+        const message = typeof j2?.message === "string" && j2.message || typeof j2?.error === "string" && j2.error || `API \uC624\uB958: ${response.status} ${response.statusText}`;
         fail(String(response.status), message);
       }
       return { data: json, traceId, status: response.status, response };
@@ -633,6 +685,12 @@ function createTtlCache(options) {
 }
 
 // src/circuitBreaker.ts
+var CircuitOpenError = class extends Error {
+  constructor(message = "\uC11C\uD0B7 OPEN \u2014 \uC694\uCCAD \uCC28\uB2E8") {
+    super(message);
+    this.name = "CircuitOpenError";
+  }
+};
 function createCircuitBreaker(options) {
   const { failureThreshold, openDurationMs, now = Date.now } = options;
   if (!Number.isInteger(failureThreshold) || failureThreshold <= 0) {
@@ -645,6 +703,7 @@ function createCircuitBreaker(options) {
   let consecutiveFailures = 0;
   let openedAtMs = 0;
   let probeInFlight = false;
+  let probeStartedAtMs = 0;
   let inFlightGrants = 0;
   function allowRequest() {
     if (state === "CLOSED") {
@@ -652,18 +711,24 @@ function createCircuitBreaker(options) {
       return true;
     }
     if (state === "OPEN") {
-      if (now() - openedAtMs >= openDurationMs) {
-        if (inFlightGrants > 0) {
+      const nowMs2 = now();
+      const elapsedMs = nowMs2 - openedAtMs;
+      if (elapsedMs < openDurationMs) return false;
+      if (inFlightGrants > 0) {
+        if (elapsedMs < 2 * openDurationMs) {
           return false;
         }
-        state = "HALF_OPEN";
-        probeInFlight = true;
-        return true;
+        inFlightGrants = 0;
       }
-      return false;
+      state = "HALF_OPEN";
+      probeInFlight = true;
+      probeStartedAtMs = nowMs2;
+      return true;
     }
-    if (probeInFlight) return false;
+    const nowMs = now();
+    if (probeInFlight && nowMs - probeStartedAtMs < openDurationMs) return false;
     probeInFlight = true;
+    probeStartedAtMs = nowMs;
     return true;
   }
   function onSuccess() {
@@ -698,13 +763,40 @@ function createCircuitBreaker(options) {
     }
     inFlightGrants = Math.max(0, inFlightGrants - 1);
   }
+  function onIgnore() {
+    if (state === "HALF_OPEN") {
+      probeInFlight = false;
+      return;
+    }
+    inFlightGrants = Math.max(0, inFlightGrants - 1);
+  }
+  async function execute(fn) {
+    if (!allowRequest()) {
+      throw new CircuitOpenError();
+    }
+    let result;
+    try {
+      result = await fn();
+    } catch (error) {
+      if (isAbortError(error)) onIgnore();
+      else onFailure();
+      throw error;
+    }
+    onSuccess();
+    return result;
+  }
   return {
     allowRequest,
     onSuccess,
     onFailure,
+    onIgnore,
+    execute,
     state: () => state
   };
 }
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
 
 // src/tokenBucket.ts
 function createTokenBucket(options) {
@@ -825,38 +917,930 @@ function isValidCorporateNumber(value) {
   const check = (10 - sum % 10) % 10;
   return check === digitAt(digits, 12);
 }
+
+// src/webhook.ts
+var WEBHOOK_SIGNATURE_HEADER = "X-Rscc-Signature";
+var DEFAULT_TOLERANCE_SECONDS = 300;
+var encoder = new TextEncoder();
+function toBytes(payload) {
+  return typeof payload === "string" ? encoder.encode(payload) : payload;
+}
+async function computeSignatureHex(secret, timestampSeconds, payload) {
+  const body = toBytes(payload);
+  const prefix = encoder.encode(`${timestampSeconds}.`);
+  const message = new Uint8Array(prefix.length + body.length);
+  message.set(prefix, 0);
+  message.set(body, prefix.length);
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await globalThis.crypto.subtle.sign("HMAC", key, message);
+  let hex = "";
+  for (const byte of new Uint8Array(signature)) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function timingSafeHexEquals(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+async function signWebhook(secret, payload, timestampSeconds) {
+  const hex = await computeSignatureHex(secret, timestampSeconds, payload);
+  return `t=${timestampSeconds},v1=${hex}`;
+}
+async function verifyWebhook(opts) {
+  if (opts.header == null || opts.header === "") return false;
+  const secrets = typeof opts.secrets === "string" ? [opts.secrets] : opts.secrets;
+  if (secrets.length === 0) return false;
+  const timestamps = [];
+  const candidates = [];
+  for (const element of opts.header.split(",")) {
+    const eq = element.indexOf("=");
+    if (eq < 0) continue;
+    const key = element.slice(0, eq).trim();
+    const value = element.slice(eq + 1).trim();
+    if (key === "t") timestamps.push(value);
+    else if (key === "v1") candidates.push(value);
+  }
+  if (timestamps.length !== 1 || candidates.length === 0) return false;
+  if (!/^[0-9]+$/.test(timestamps[0])) return false;
+  const t = Number(timestamps[0]);
+  const now = opts.nowSeconds ?? Math.floor(Date.now() / 1e3);
+  const tolerance = opts.toleranceSeconds ?? DEFAULT_TOLERANCE_SECONDS;
+  if (Math.abs(now - t) > tolerance) return false;
+  let matched = false;
+  for (const secret of secrets) {
+    const expected = await computeSignatureHex(secret, t, opts.payload);
+    for (const candidate of candidates) {
+      if (timingSafeHexEquals(expected, candidate)) matched = true;
+    }
+  }
+  return matched;
+}
+
+// src/bulk.ts
+function isBulkResult(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.total !== "number" || typeof v.succeeded !== "number" || typeof v.failed !== "number") {
+    return false;
+  }
+  if (!Array.isArray(v.items)) return false;
+  return v.items.every(
+    (item) => typeof item === "object" && item !== null && typeof item.index === "number"
+    // 각 요소 index 필수 (BK-04)
+  );
+}
+function bulkFailures(result) {
+  return result.items.filter((item) => item.code !== void 0);
+}
+function createBulkResultBuilder() {
+  let succeeded = 0;
+  let failed = 0;
+  const items = [];
+  const builder = {
+    success(index, id) {
+      succeeded += 1;
+      if (id !== void 0) items.push({ index, id });
+      return builder;
+    },
+    failure(index, code, message) {
+      failed += 1;
+      items.push({ index, code, message });
+      return builder;
+    },
+    build() {
+      return { total: succeeded + failed, succeeded, failed, items: [...items] };
+    }
+  };
+  return builder;
+}
+
+// src/upload.ts
+function bytesAt(head, offset, bytes) {
+  if (head.length < offset + bytes.length) return false;
+  for (let i = 0; i < bytes.length; i++) {
+    if (head[offset + i] !== bytes[i]) return false;
+  }
+  return true;
+}
+var HWP3_SIGNATURE = [..."HWP Document File"].map((ch) => ch.charCodeAt(0));
+var SNIFF_TABLE = [
+  { kind: "png", matches: (h) => bytesAt(h, 0, [137, 80, 78, 71, 13, 10, 26, 10]) },
+  // 3바이트 — JFIF/EXIF/원시 모두 커버.
+  { kind: "jpeg", matches: (h) => bytesAt(h, 0, [255, 216, 255]) },
+  // "GIF87a" / "GIF89a"
+  {
+    kind: "gif",
+    matches: (h) => bytesAt(h, 0, [71, 73, 70, 56, 55, 97]) || bytesAt(h, 0, [71, 73, 70, 56, 57, 97])
+  },
+  // RIFF 컨테이너 — 4~7 바이트(크기)는 임의, 8~11 이 "WEBP" 여야 한다.
+  {
+    kind: "webp",
+    matches: (h) => bytesAt(h, 0, [82, 73, 70, 70]) && bytesAt(h, 8, [87, 69, 66, 80])
+  },
+  // "%PDF-"
+  { kind: "pdf", matches: (h) => bytesAt(h, 0, [37, 80, 68, 70, 45]) },
+  // PK♥♦ 외 2종 — docx/xlsx/pptx/hwpx 도 ZIP (컨테이너 수준 판정).
+  {
+    kind: "zip",
+    matches: (h) => bytesAt(h, 0, [80, 75, 3, 4]) || bytesAt(h, 0, [80, 75, 5, 6]) || bytesAt(h, 0, [80, 75, 7, 8])
+  },
+  // MS 복합문서 — hwp(5.0)/doc/xls/ppt (컨테이너 수준 판정).
+  { kind: "cfbf", matches: (h) => bytesAt(h, 0, [208, 207, 17, 224, 161, 177, 26, 225]) },
+  { kind: "hwp3", matches: (h) => bytesAt(h, 0, HWP3_SIGNATURE) }
+];
+var EXTENSION_KINDS = {
+  png: ["png"],
+  jpg: ["jpeg"],
+  jpeg: ["jpeg"],
+  gif: ["gif"],
+  webp: ["webp"],
+  pdf: ["pdf"],
+  zip: ["zip"],
+  docx: ["zip"],
+  xlsx: ["zip"],
+  pptx: ["zip"],
+  hwpx: ["zip"],
+  doc: ["cfbf"],
+  xls: ["cfbf"],
+  ppt: ["cfbf"],
+  hwp: ["cfbf", "hwp3"]
+  // HWP 5.0 = CFBF 컨테이너, 3.x = 자체 시그니처
+};
+function sniffFile(head) {
+  const bytes = head instanceof Uint8Array ? head : new Uint8Array(head);
+  for (const { kind, matches } of SNIFF_TABLE) {
+    if (matches(bytes)) return kind;
+  }
+  return null;
+}
+function kindsForExtension(ext) {
+  const normalized = (ext.startsWith(".") ? ext.slice(1) : ext).toLowerCase();
+  return new Set(EXTENSION_KINDS[normalized] ?? []);
+}
+function extensionOf(fileName) {
+  const dot = fileName.lastIndexOf(".");
+  if (dot < 0 || dot === fileName.length - 1) return "";
+  return fileName.slice(dot + 1).toLowerCase();
+}
+function validateUpload(input) {
+  if (input.size > input.maxSizeBytes) {
+    return { ok: false, reason: "size", message: "\uC5C5\uB85C\uB4DC \uAC00\uB2A5\uD55C \uCD5C\uB300 \uD06C\uAE30\uB97C \uCD08\uACFC\uD588\uC2B5\uB2C8\uB2E4." };
+  }
+  const ext = extensionOf(input.fileName);
+  const allowed = input.allowedExtensions.map(
+    (e) => (e.startsWith(".") ? e.slice(1) : e).toLowerCase()
+  );
+  if (ext === "" || !allowed.includes(ext)) {
+    return { ok: false, reason: "extension", message: `\uD5C8\uC6A9\uB418\uC9C0 \uC54A\uB294 \uD30C\uC77C \uD615\uC2DD\uC785\uB2C8\uB2E4: ${ext}` };
+  }
+  const extra = input.extraMappings?.[ext];
+  const kinds = extra !== void 0 ? new Set(extra) : kindsForExtension(ext);
+  const kind = sniffFile(input.head);
+  if (kind === null || !kinds.has(kind)) {
+    return {
+      ok: false,
+      reason: "content-mismatch",
+      message: "\uD30C\uC77C \uB0B4\uC6A9\uC774 \uD655\uC7A5\uC790\uC640 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."
+    };
+  }
+  return { ok: true };
+}
+
+// src/query.ts
+var RESERVED_FILTER_NAMES = /* @__PURE__ */ new Set(["page", "size", "sort"]);
+function buildListQuery(options) {
+  const params = new URLSearchParams();
+  if (options.page !== void 0) params.append("page", String(options.page));
+  if (options.size !== void 0) params.append("size", String(options.size));
+  for (const { field, direction } of options.sort ?? []) {
+    params.append("sort", direction === void 0 ? field : `${field},${direction}`);
+  }
+  for (const [name, value] of Object.entries(options.filters ?? {})) {
+    if (RESERVED_FILTER_NAMES.has(name)) {
+      throw new RangeError(`\uC608\uC57D\uB41C \uD30C\uB77C\uBBF8\uD130 \uC774\uB984\uC740 \uD544\uD130\uB85C \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${name}`);
+    }
+    if (value === null || value === void 0) continue;
+    const values = Array.isArray(value) ? value : [value];
+    for (const v of values) params.append(name, String(v));
+  }
+  return params;
+}
+
+// src/featureFlags.ts
+var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "on", "yes"]);
+function parseFlag(value) {
+  if (typeof value === "boolean") return value;
+  if (value == null) return false;
+  return TRUE_VALUES.has(value.trim().toLowerCase());
+}
+function createFeatureFlags(source) {
+  return {
+    isEnabled(key, defaultValue = false) {
+      const value = Object.prototype.hasOwnProperty.call(source, key) ? source[key] : void 0;
+      if (value === void 0) return defaultValue;
+      return parseFlag(value);
+    }
+  };
+}
+
+// src/rrn.ts
+var SEPARATOR_PATTERN2 = /[-\t ]/g;
+var RRN_DIGITS_PATTERN = /^[0-9]{13}$/;
+var LEGACY_WEIGHTS = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5];
+var digitAt2 = (digits, i) => digits.charCodeAt(i) - 48;
+var isLeapYear = (year) => year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function centuryOf(genderCode) {
+  if (genderCode === 1 || genderCode === 2 || genderCode === 5 || genderCode === 6) return 1900;
+  if (genderCode === 3 || genderCode === 4 || genderCode === 7 || genderCode === 8) return 2e3;
+  return null;
+}
+function parseRrn(value) {
+  if (value == null) return null;
+  const digits = normalizeRrn(value);
+  if (!RRN_DIGITS_PATTERN.test(digits)) return null;
+  const century = centuryOf(digitAt2(digits, 6));
+  if (century === null) return null;
+  const year = century + digitAt2(digits, 0) * 10 + digitAt2(digits, 1);
+  const month = digitAt2(digits, 2) * 10 + digitAt2(digits, 3);
+  const day = digitAt2(digits, 4) * 10 + digitAt2(digits, 5);
+  if (month < 1 || month > 12) return null;
+  const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+  if (day < 1 || day > maxDay) return null;
+  return { digits, year, month, day };
+}
+function normalizeRrn(value) {
+  if (value == null) return value;
+  return value.replace(SEPARATOR_PATTERN2, "");
+}
+function isValidRrn(value) {
+  return parseRrn(value) !== null;
+}
+function isForeignerRrn(value) {
+  const parsed = parseRrn(value);
+  if (parsed === null) return false;
+  const genderCode = digitAt2(parsed.digits, 6);
+  return genderCode >= 5 && genderCode <= 8;
+}
+function rrnChecksumOkLegacy(value) {
+  const parsed = parseRrn(value);
+  if (parsed === null) return false;
+  const { digits } = parsed;
+  let sum = 0;
+  for (const [i, weight] of LEGACY_WEIGHTS.entries()) sum += digitAt2(digits, i) * weight;
+  let check = (11 - sum % 11) % 10;
+  const genderCode = digitAt2(digits, 6);
+  if (genderCode >= 5 && genderCode <= 8) check = (check + 2) % 10;
+  return check === digitAt2(digits, 12);
+}
+function rrnBirthDate(value) {
+  const parsed = parseRrn(value);
+  if (parsed === null) return null;
+  const pad2 = (n) => String(n).padStart(2, "0");
+  return `${parsed.year}-${pad2(parsed.month)}-${pad2(parsed.day)}`;
+}
+
+// src/josa.ts
+var HANGUL_BASE2 = 44032;
+var HANGUL_END2 = 55203;
+var JONG_RIEUL = 8;
+var DIGIT_READINGS = "\uC601\uC77C\uC774\uC0BC\uC0AC\uC624\uC721\uCE60\uD314\uAD6C";
+var JOSA_TABLE = {
+  "\uC740/\uB294": ["\uC740", "\uB294", "\uC740(\uB294)"],
+  "\uC774/\uAC00": ["\uC774", "\uAC00", "\uC774(\uAC00)"],
+  "\uC744/\uB97C": ["\uC744", "\uB97C", "\uC744(\uB97C)"],
+  "\uACFC/\uC640": ["\uACFC", "\uC640", "\uACFC(\uC640)"],
+  "(\uC73C)\uB85C": ["\uC73C\uB85C", "\uB85C", "(\uC73C)\uB85C"],
+  "\uC544/\uC57C": ["\uC544", "\uC57C", "\uC544(\uC57C)"]
+};
+function lastJongOf(word) {
+  let end = word.length;
+  while (end > 0 && (word[end - 1] === " " || word[end - 1] === "	")) end--;
+  if (end === 0) return null;
+  let c = word.codePointAt(end - 1);
+  if (c >= 56320 && c <= 57343 && end >= 2) c = word.codePointAt(end - 2);
+  if (c >= 48 && c <= 57) {
+    c = DIGIT_READINGS.codePointAt(c - 48);
+  }
+  if (c >= HANGUL_BASE2 && c <= HANGUL_END2) return (c - HANGUL_BASE2) % 28;
+  return null;
+}
+function pickJosa(word, josa) {
+  const entry = JOSA_TABLE[josa];
+  if (entry === void 0) throw new RangeError(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC870\uC0AC \uC30D\uC785\uB2C8\uB2E4: ${josa}`);
+  const jong = lastJongOf(word);
+  if (jong === null) return entry[2];
+  if (josa === "(\uC73C)\uB85C") return jong === 0 || jong === JONG_RIEUL ? "\uB85C" : "\uC73C\uB85C";
+  return jong > 0 ? entry[0] : entry[1];
+}
+function attachJosa(word, josa) {
+  let end = word.length;
+  while (end > 0 && (word[end - 1] === " " || word[end - 1] === "	")) end--;
+  return word.slice(0, end) + pickJosa(word, josa);
+}
+
+// src/age.ts
+var DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+var isLeapYear2 = (year) => year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+var DAYS_IN_MONTH2 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function parseDate(value, label) {
+  const m = typeof value === "string" ? value.match(DATE_PATTERN) : null;
+  if (!m) throw new RangeError(`${label}\uC740(\uB294) "YYYY-MM-DD" \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4: ${value}`);
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  const maxDay = month >= 1 && month <= 12 ? month === 2 && isLeapYear2(year) ? 29 : DAYS_IN_MONTH2[month - 1] : 0;
+  if (month < 1 || month > 12 || day < 1 || day > maxDay) {
+    throw new RangeError(`\uC2E4\uC874\uD558\uC9C0 \uC54A\uB294 \uB0A0\uC9DC\uC785\uB2C8\uB2E4: ${value}`);
+  }
+  return { year, month, day };
+}
+var monthDayBefore = (a, b) => a.month < b.month || a.month === b.month && a.day < b.day;
+function parsePair(birth, on) {
+  const b = parseDate(birth, "\uC0DD\uC77C");
+  const o = parseDate(on, "\uAE30\uC900\uC77C");
+  if (o.year < b.year || o.year === b.year && (o.month < b.month || o.month === b.month && o.day < b.day)) {
+    throw new RangeError(`\uAE30\uC900\uC77C(${on})\uC774 \uC0DD\uC77C(${birth})\uBCF4\uB2E4 \uC55E\uC124 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4`);
+  }
+  return [b, o];
+}
+function ageMan(birth, on) {
+  const [b, o] = parsePair(birth, on);
+  return o.year - b.year - (monthDayBefore(o, b) ? 1 : 0);
+}
+function ageByYear(birth, on) {
+  const [b, o] = parsePair(birth, on);
+  return o.year - b.year;
+}
+function ageInsurance(birth, on) {
+  const [b, o] = parsePair(birth, on);
+  const months = (o.year - b.year) * 12 + (o.month - b.month) - (o.day < b.day ? 1 : 0);
+  return Math.floor((months + 6) / 12);
+}
+
+// src/phone.ts
+var SEPARATOR_PATTERN3 = /[-\t ().]/g;
+var AREA_CODES = /* @__PURE__ */ new Set([
+  "031",
+  "032",
+  "033",
+  "041",
+  "042",
+  "043",
+  "044",
+  "051",
+  "052",
+  "053",
+  "054",
+  "055",
+  "061",
+  "062",
+  "063",
+  "064"
+]);
+var MOBILE_PREFIXES = /* @__PURE__ */ new Set(["011", "016", "017", "018", "019"]);
+var DIGITS_ONLY = /^[0-9]+$/;
+function normalizePhoneNumber(value) {
+  if (value == null) return value;
+  const stripped = value.replace(SEPARATOR_PATTERN3, "");
+  if (stripped.startsWith("+82")) {
+    const rest = stripped.slice(3);
+    return rest.startsWith("0") ? rest : "0" + rest;
+  }
+  return stripped;
+}
+function classifyPhoneNumber(value) {
+  const digits = normalizePhoneNumber(value);
+  if (digits == null || !DIGITS_ONLY.test(digits)) return "unknown";
+  const len = digits.length;
+  const p3 = digits.slice(0, 3);
+  if (p3 === "010") return len === 11 ? "mobile" : "unknown";
+  if (MOBILE_PREFIXES.has(p3)) return len === 10 || len === 11 ? "mobile" : "unknown";
+  if (p3 === "070") return len === 11 ? "voip" : "unknown";
+  if (p3 === "012") return len === 11 || len === 12 ? "m2m" : "unknown";
+  if (/^050[0-9]/.test(digits)) return len === 11 || len === 12 ? "safe" : "unknown";
+  if (digits.startsWith("02")) return len === 9 || len === 10 ? "landline" : "unknown";
+  if (AREA_CODES.has(p3)) return len === 10 || len === 11 ? "landline" : "unknown";
+  return "unknown";
+}
+function formatPhoneNumber(value) {
+  const digits = normalizePhoneNumber(value);
+  if (digits == null) return digits;
+  const type = classifyPhoneNumber(digits);
+  if (type === "unknown") return digits;
+  const len = digits.length;
+  if (digits.startsWith("02")) {
+    return `${digits.slice(0, 2)}-${digits.slice(2, len - 4)}-${digits.slice(len - 4)}`;
+  }
+  if (type === "safe") {
+    return `${digits.slice(0, 4)}-${digits.slice(4, len - 4)}-${digits.slice(len - 4)}`;
+  }
+  if (type === "m2m" && len === 12) return digits;
+  return `${digits.slice(0, 3)}-${digits.slice(3, len - 4)}-${digits.slice(len - 4)}`;
+}
+function toE164(value) {
+  const digits = normalizePhoneNumber(value);
+  if (digits == null || classifyPhoneNumber(digits) === "unknown") return null;
+  return "+82" + digits.slice(1);
+}
+
+// src/money.ts
+var LIMIT = 10n ** 20n;
+var TRILLION = 10n ** 12n;
+var HUNDRED_MILLION = 10n ** 8n;
+var TEN_THOUSAND = 10n ** 4n;
+var DIGIT_WORDS = ["", "\uC77C", "\uC774", "\uC0BC", "\uC0AC", "\uC624", "\uC721", "\uCE60", "\uD314", "\uAD6C"];
+var PLACE_WORDS = ["", "\uC2ED", "\uBC31", "\uCC9C"];
+var GROUP_WORDS = ["", "\uB9CC", "\uC5B5", "\uC870", "\uACBD"];
+function toBigInt(amount) {
+  let value;
+  if (typeof amount === "bigint") {
+    value = amount;
+  } else {
+    if (!Number.isSafeInteger(amount)) {
+      throw new RangeError(`\uAE08\uC561\uC740 \uC548\uC804 \uC815\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${amount}`);
+    }
+    value = BigInt(amount);
+  }
+  if (value >= LIMIT || value <= -LIMIT) {
+    throw new RangeError(`\uC9C0\uC6D0 \uBC94\uC704(|amount| < 10^20)\uB97C \uCD08\uACFC\uD588\uC2B5\uB2C8\uB2E4: ${value}`);
+  }
+  return value;
+}
+function groupWords(group, explicitOne) {
+  let out = "";
+  for (let place = 3; place >= 0; place--) {
+    const d = Math.floor(group / 10 ** place) % 10;
+    if (d === 0) continue;
+    if (d === 1 && place > 0 && !explicitOne) {
+      out += PLACE_WORDS[place];
+    } else {
+      out += DIGIT_WORDS[d] + PLACE_WORDS[place];
+    }
+  }
+  return out;
+}
+function wordsOfPositive(abs, explicitOne) {
+  const groups = [];
+  let rest = abs;
+  while (rest > 0n) {
+    groups.push(Number(rest % 10000n));
+    rest /= 10000n;
+  }
+  let out = "";
+  for (let gi = groups.length - 1; gi >= 0; gi--) {
+    const group = groups[gi];
+    if (group === 0) continue;
+    const body = group === 1 && gi > 0 ? "\uC77C" : groupWords(group, explicitOne);
+    out += body + GROUP_WORDS[gi];
+  }
+  return out;
+}
+var withCommas = (digits) => digits.replace(/\B(?=(\d{3})+$)/g, ",");
+function toKoreanWords(amount) {
+  const value = toBigInt(amount);
+  if (value === 0n) return "\uC601";
+  if (value < 0n) return "\uB9C8\uC774\uB108\uC2A4 " + wordsOfPositive(-value, false);
+  return wordsOfPositive(value, false);
+}
+function toFormalNotation(amount) {
+  const value = toBigInt(amount);
+  if (value < 0n) throw new RangeError(`\uACF5\uBB38\uC11C \uD45C\uAE30\uB294 \uC74C\uC218\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4: ${value}`);
+  if (value === 0n) return "\uAE08\uC601\uC6D0\u6574";
+  return "\uAE08" + wordsOfPositive(value, true) + "\uC6D0\u6574";
+}
+function scaledOneDecimal(abs, unit) {
+  const intPart = abs / unit;
+  const tenth = abs % unit * 10n / unit;
+  const intStr = withCommas(intPart.toString());
+  return tenth > 0n ? `${intStr}.${tenth}` : intStr;
+}
+function abbreviateAmount(amount) {
+  const value = toBigInt(amount);
+  const sign = value < 0n ? "-" : "";
+  const abs = value < 0n ? -value : value;
+  if (abs >= TRILLION) return sign + scaledOneDecimal(abs, TRILLION) + "\uC870";
+  if (abs >= HUNDRED_MILLION) return sign + scaledOneDecimal(abs, HUNDRED_MILLION) + "\uC5B5";
+  if (abs >= TEN_THOUSAND) return sign + withCommas((abs / TEN_THOUSAND).toString()) + "\uB9CC";
+  return sign + withCommas(abs.toString());
+}
+
+// src/businessDays.ts
+var DATE_PATTERN2 = /^(\d{4})-(\d{2})-(\d{2})$/;
+var MS_PER_DAY = 864e5;
+var isLeapYear3 = (year) => year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+var DAYS_IN_MONTH3 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function toEpochDay(value) {
+  const m = typeof value === "string" ? value.match(DATE_PATTERN2) : null;
+  if (!m) throw new RangeError(`\uB0A0\uC9DC\uB294 "YYYY-MM-DD" \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4: ${value}`);
+  const year = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  const maxDay = month >= 1 && month <= 12 ? month === 2 && isLeapYear3(year) ? 29 : DAYS_IN_MONTH3[month - 1] : 0;
+  if (month < 1 || month > 12 || day < 1 || day > maxDay) {
+    throw new RangeError(`\uC2E4\uC874\uD558\uC9C0 \uC54A\uB294 \uB0A0\uC9DC\uC785\uB2C8\uB2E4: ${value}`);
+  }
+  return Date.UTC(year, month - 1, day) / MS_PER_DAY;
+}
+function fromEpochDay(epochDay) {
+  const d = new Date(epochDay * MS_PER_DAY);
+  const pad2 = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+}
+function isWeekend(epochDay) {
+  const dow = ((epochDay + 4) % 7 + 7) % 7;
+  return dow === 0 || dow === 6;
+}
+function createBusinessDays(options) {
+  const holidaySet = /* @__PURE__ */ new Set();
+  for (const holiday of options.holidays) holidaySet.add(toEpochDay(holiday));
+  const isBusinessEpochDay = (epochDay) => !isWeekend(epochDay) && !holidaySet.has(epochDay);
+  const stepUntilBusiness = (epochDay, step) => {
+    let day = epochDay + step;
+    while (!isBusinessEpochDay(day)) day += step;
+    return day;
+  };
+  return {
+    isBusinessDay(date) {
+      return isBusinessEpochDay(toEpochDay(date));
+    },
+    addBusinessDays(date, n) {
+      let day = toEpochDay(date);
+      if (!Number.isInteger(n)) throw new RangeError(`n \uC740 \uC815\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4: ${n}`);
+      const step = n < 0 ? -1 : 1;
+      for (let remaining = Math.abs(n); remaining > 0; remaining--) {
+        day = stepUntilBusiness(day, step);
+      }
+      return fromEpochDay(day);
+    },
+    nextBusinessDay(date) {
+      return fromEpochDay(stepUntilBusiness(toEpochDay(date), 1));
+    },
+    previousBusinessDay(date) {
+      return fromEpochDay(stepUntilBusiness(toEpochDay(date), -1));
+    },
+    countBusinessDays(start, endExclusive) {
+      const startDay = toEpochDay(start);
+      const endDay = toEpochDay(endExclusive);
+      if (startDay > endDay) {
+        throw new RangeError(`start(${start})\uAC00 end(${endExclusive})\uBCF4\uB2E4 \uB4A4\uC77C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4`);
+      }
+      let count = 0;
+      for (let day = startDay; day < endDay; day++) {
+        if (isBusinessEpochDay(day)) count++;
+      }
+      return count;
+    }
+  };
+}
+
+// src/jamo.ts
+var HANGUL_BASE3 = 44032;
+var HANGUL_END3 = 55203;
+var CHO_DIV2 = 21 * 28;
+var COMPAT_CONS_START2 = 12593;
+var COMPAT_CONS_END2 = 12622;
+var COMPAT_VOWEL_START2 = 12623;
+var COMPAT_VOWEL_END2 = 12643;
+var j = String.fromCharCode;
+var CHO_CODEPOINTS = [
+  12593,
+  12594,
+  12596,
+  12599,
+  12600,
+  12601,
+  12609,
+  12610,
+  12611,
+  12613,
+  12614,
+  12615,
+  12616,
+  12617,
+  12618,
+  12619,
+  12620,
+  12621,
+  12622
+];
+var JUNG_DECOMP = [
+  j(12623),
+  j(12624),
+  j(12625),
+  j(12626),
+  j(12627),
+  j(12628),
+  j(12629),
+  j(12630),
+  j(12631),
+  // ㅗ
+  j(12631) + j(12623),
+  // ㅘ→ㅗㅏ
+  j(12631) + j(12624),
+  // ㅙ→ㅗㅐ
+  j(12631) + j(12643),
+  // ㅚ→ㅗㅣ
+  j(12635),
+  // ㅛ
+  j(12636),
+  // ㅜ
+  j(12636) + j(12627),
+  // ㅝ→ㅜㅓ
+  j(12636) + j(12628),
+  // ㅞ→ㅜㅔ
+  j(12636) + j(12643),
+  // ㅟ→ㅜㅣ
+  j(12640),
+  // ㅠ
+  j(12641),
+  // ㅡ
+  j(12641) + j(12643),
+  // ㅢ→ㅡㅣ
+  j(12643)
+  // ㅣ
+];
+var JONG_DECOMP = [
+  "",
+  j(12593),
+  // ㄱ
+  j(12594),
+  // ㄲ (비분해)
+  j(12593) + j(12613),
+  // ㄳ→ㄱㅅ
+  j(12596),
+  // ㄴ
+  j(12596) + j(12616),
+  // ㄵ→ㄴㅈ
+  j(12596) + j(12622),
+  // ㄶ→ㄴㅎ
+  j(12599),
+  // ㄷ
+  j(12601),
+  // ㄹ
+  j(12601) + j(12593),
+  // ㄺ→ㄹㄱ
+  j(12601) + j(12609),
+  // ㄻ→ㄹㅁ
+  j(12601) + j(12610),
+  // ㄼ→ㄹㅂ
+  j(12601) + j(12613),
+  // ㄽ→ㄹㅅ
+  j(12601) + j(12620),
+  // ㄾ→ㄹㅌ
+  j(12601) + j(12621),
+  // ㄿ→ㄹㅍ
+  j(12601) + j(12622),
+  // ㅀ→ㄹㅎ
+  j(12609),
+  // ㅁ
+  j(12610),
+  // ㅂ
+  j(12610) + j(12613),
+  // ㅄ→ㅂㅅ
+  j(12613),
+  // ㅅ
+  j(12614),
+  // ㅆ (비분해)
+  j(12615),
+  // ㅇ
+  j(12616),
+  // ㅈ
+  j(12618),
+  // ㅊ
+  j(12619),
+  // ㅋ
+  j(12620),
+  // ㅌ
+  j(12621),
+  // ㅍ
+  j(12622)
+  // ㅎ
+];
+var CHO_INDEX = new Map(CHO_CODEPOINTS.map((cp, idx) => [cp, idx]));
+var JONG_INDEX = /* @__PURE__ */ new Map([
+  [12593, 1],
+  [12594, 2],
+  [12595, 3],
+  [12596, 4],
+  [12597, 5],
+  [12598, 6],
+  [12599, 7],
+  [12601, 8],
+  [12602, 9],
+  [12603, 10],
+  [12604, 11],
+  [12605, 12],
+  [12606, 13],
+  [12607, 14],
+  [12608, 15],
+  [12609, 16],
+  [12610, 17],
+  [12612, 18],
+  [12613, 19],
+  [12614, 20],
+  [12615, 21],
+  [12616, 22],
+  [12618, 23],
+  [12619, 24],
+  [12620, 25],
+  [12621, 26],
+  [12622, 27]
+]);
+var VOWEL_COMBINE = /* @__PURE__ */ new Map([
+  [12631 << 16 | 12623, 12632],
+  // ㅗ+ㅏ→ㅘ
+  [12631 << 16 | 12624, 12633],
+  // ㅗ+ㅐ→ㅙ
+  [12631 << 16 | 12643, 12634],
+  // ㅗ+ㅣ→ㅚ
+  [12636 << 16 | 12627, 12637],
+  // ㅜ+ㅓ→ㅝ
+  [12636 << 16 | 12628, 12638],
+  // ㅜ+ㅔ→ㅞ
+  [12636 << 16 | 12643, 12639],
+  // ㅜ+ㅣ→ㅟ
+  [12641 << 16 | 12643, 12642]
+  // ㅡ+ㅣ→ㅢ
+]);
+var JONG_COMBINE = /* @__PURE__ */ new Map([
+  [12593 << 16 | 12613, 12595],
+  // ㄱ+ㅅ→ㄳ
+  [12596 << 16 | 12616, 12597],
+  // ㄴ+ㅈ→ㄵ
+  [12596 << 16 | 12622, 12598],
+  // ㄴ+ㅎ→ㄶ
+  [12601 << 16 | 12593, 12602],
+  // ㄹ+ㄱ→ㄺ
+  [12601 << 16 | 12609, 12603],
+  // ㄹ+ㅁ→ㄻ
+  [12601 << 16 | 12610, 12604],
+  // ㄹ+ㅂ→ㄼ
+  [12601 << 16 | 12613, 12605],
+  // ㄹ+ㅅ→ㄽ
+  [12601 << 16 | 12620, 12606],
+  // ㄹ+ㅌ→ㄾ
+  [12601 << 16 | 12621, 12607],
+  // ㄹ+ㅍ→ㄿ
+  [12601 << 16 | 12622, 12608],
+  // ㄹ+ㅎ→ㅀ
+  [12610 << 16 | 12613, 12612]
+  // ㅂ+ㅅ→ㅄ
+]);
+var isVowelCp = (cp) => cp >= COMPAT_VOWEL_START2 && cp <= COMPAT_VOWEL_END2;
+function decomposeHangul(s) {
+  if (!s) return "";
+  let out = "";
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if (cp >= HANGUL_BASE3 && cp <= HANGUL_END3) {
+      const idx = cp - HANGUL_BASE3;
+      out += j(CHO_CODEPOINTS[Math.floor(idx / CHO_DIV2)]);
+      out += JUNG_DECOMP[Math.floor(idx / 28) % 21];
+      out += JONG_DECOMP[idx % 28];
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+}
+function composeHangul(s) {
+  const chars = Array.from(s);
+  const n = chars.length;
+  const cpAt = (idx) => idx >= 0 && idx < n ? chars[idx].codePointAt(0) : -1;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const choIdx = CHO_INDEX.get(cpAt(i));
+    if (choIdx === void 0 || !isVowelCp(cpAt(i + 1))) {
+      out += chars[i];
+      i++;
+      continue;
+    }
+    i++;
+    let jungCp = cpAt(i);
+    i++;
+    const combinedVowel = VOWEL_COMBINE.get(jungCp << 16 | cpAt(i));
+    if (combinedVowel !== void 0) {
+      jungCp = combinedVowel;
+      i++;
+    }
+    let jongIdx = 0;
+    const jong1Cp = cpAt(i);
+    const jong1Idx = JONG_INDEX.get(jong1Cp);
+    if (jong1Idx !== void 0 && !isVowelCp(cpAt(i + 1))) {
+      jongIdx = jong1Idx;
+      i++;
+      const combinedJong = JONG_COMBINE.get(jong1Cp << 16 | cpAt(i));
+      if (combinedJong !== void 0 && !isVowelCp(cpAt(i + 1))) {
+        jongIdx = JONG_INDEX.get(combinedJong);
+        i++;
+      }
+    }
+    out += j(HANGUL_BASE3 + choIdx * CHO_DIV2 + (jungCp - COMPAT_VOWEL_START2) * 28 + jongIdx);
+  }
+  return out;
+}
+function matchesHangul(query, target) {
+  const q = Array.from(query);
+  const t = Array.from(target);
+  if (q.length === 0) return true;
+  if (q.length > t.length) return false;
+  for (let i = 0; i < q.length; i++) {
+    const qc = q[i];
+    const tc = t[i];
+    if (i === q.length - 1) {
+      const qd = decomposeHangul(qc.toLowerCase());
+      const td = decomposeHangul(tc.toLowerCase());
+      if (!td.startsWith(qd)) return false;
+      continue;
+    }
+    if (qc === tc) continue;
+    const qcp = qc.codePointAt(0);
+    const tcp = tc.codePointAt(0);
+    if (qcp >= COMPAT_CONS_START2 && qcp <= COMPAT_CONS_END2 && tcp >= HANGUL_BASE3 && tcp <= HANGUL_END3) {
+      if (qcp === CHO_CODEPOINTS[Math.floor((tcp - HANGUL_BASE3) / CHO_DIV2)]) continue;
+      return false;
+    }
+    if (qc.toLowerCase() === tc.toLowerCase()) continue;
+    return false;
+  }
+  return true;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiError,
   BulkheadFullError,
+  CircuitOpenError,
   ResultCode,
+  WEBHOOK_SIGNATURE_HEADER,
+  abbreviateAmount,
+  ageByYear,
+  ageInsurance,
+  ageMan,
+  attachJosa,
+  buildListQuery,
+  bulkFailures,
+  classifyPhoneNumber,
+  composeHangul,
   createApiClient,
+  createBulkResultBuilder,
   createBulkhead,
+  createBusinessDays,
   createCircuitBreaker,
+  createFeatureFlags,
   createTokenBucket,
   createTtlCache,
   decodeJwtPayload,
+  decomposeHangul,
+  formatPhoneNumber,
+  generateIdempotencyKey,
   getTokenExpiry,
+  isBulkResult,
   isChosungQuery,
+  isForeignerRrn,
   isRetryableStatus,
   isTokenExpired,
   isValidBusinessNumber,
   isValidCorporateNumber,
+  isValidRrn,
   isValidationErrorData,
+  kindsForExtension,
   maskCardNumber,
   maskEmail,
   maskName,
   maskPhone,
   maskSecret,
+  matchesHangul,
   normalizeBusinessNumber,
+  normalizePhoneNumber,
+  normalizeRrn,
+  parseFlag,
   parseRetryAfterMs,
   parseSseFrame,
   parseWireDateTime,
+  pickJosa,
   readSseStream,
   retry,
+  rrnBirthDate,
+  rrnChecksumOkLegacy,
   sanitizeLogValue,
+  signWebhook,
+  sniffFile,
   stripZone,
   toChosung,
+  toE164,
+  toFormalNotation,
+  toKoreanWords,
   toWireDate,
-  toWireDateTime
+  toWireDateTime,
+  validateUpload,
+  verifyWebhook
 });