@ingestkorea/client-sens 1.9.0 → 1.10.0

package/dist-es/SensClient.js

@@ -23,8 +23,14 @@ class SensClient {
             const output = await deserializer(response, this.config);
             return output;
         }
-        catch (e) {
-            throw e;
+        catch (err) {
+            if (err instanceof index_js_1.SensError)
+                throw err;
+            throw new index_js_1.SensError({
+                code: -1,
+                type: "SDK.UNKNOWN_ERROR",
+                message: err instanceof Error ? err.message : "unknown error",
+            });
         }
     }
 }
@@ -37,20 +43,19 @@ const composeMiddleware = (middlewares, finalHandler) => {
 };
 const resolveCredentials = (config) => {
     const { credentials } = config;
-    let error = new index_js_1.SensError({
-        code: 401,
-        type: "Unauthorized",
-        message: "Invalid Credentials",
-        invalidInputs: [{ type: "not-valid.args", message: "SensClient 초기화시 인증 정보를 확인해주세요" }],
+    const error = new index_js_1.SensError({
+        code: -1,
+        type: "SDK.AUTH_ERROR",
+        message: "SensClient 초기화시 인증 정보를 입력해주세요.",
     });
     if (!credentials)
         throw error;
     if (!credentials.accessKey) {
-        error.invalidInputs[0].message = "AccessKey 정보를 확인해주세요";
+        error.message = "AccessKey 정보를 확인해주세요.";
         throw error;
     }
     if (!credentials.secretKey) {
-        error.invalidInputs[0].message = "SecretKey 정보를 확인해주세요";
+        error.message = "SecretKey 정보를 확인해주세요.";
         throw error;
     }
     return {
@@ -59,24 +64,22 @@ const resolveCredentials = (config) => {
     };
 };
 const resolveServiceId = (config) => {
-    var _a, _b, _c;
+    var _a, _b;
     const { serviceId } = config;
-    let error = new index_js_1.SensError({
-        code: 400,
-        type: "Bad Request",
-        message: "Invalid ServiceId",
-        invalidInputs: [{ type: "not-valid.args", message: "SensClient 초기화시 서비스 정보를 확인해주세요" }],
+    const error = new index_js_1.SensError({
+        code: -1,
+        type: "SDK.GENERAL_ERROR",
+        message: "SensClient 초기화시 사용할 서비스 정보를 입력해주세요.",
     });
     if (!serviceId)
         throw error;
     const isReady = !!Object.values(serviceId).filter((d) => !!d).length;
     if (!isReady) {
-        error.invalidInputs[0].message = "최소 1개 이상의 서비스 정보가 필요합니다";
+        error.message = "최소 1개 이상의 서비스 정보가 필요합니다";
         throw error;
     }
     return {
         kakao: (_a = serviceId.kakao) !== null && _a !== void 0 ? _a : "",
-        push: (_b = serviceId.push) !== null && _b !== void 0 ? _b : "",
-        sms: (_c = serviceId.sms) !== null && _c !== void 0 ? _c : "",
+        sms: (_b = serviceId.sms) !== null && _b !== void 0 ? _b : "",
     };
 };

package/dist-es/commands/ListAlimtalkStatusCommand.js

@@ -13,14 +13,12 @@ class ListAlimtalkStatusCommand extends index_js_1.SensCommand {
         super(input);
         if (input.nextToken && (!input.requestStartTime || !input.requestEndTime)) {
             throw new index_js_1.SensError({
-                code: 400,
-                type: "Bad Request",
+                code: -1,
+                type: "SDK.GENERAL_ERROR",
                 message: "페이지네이션 검색 조건 불일치",
-                invalidInputs: [
-                    {
-                        type: "not-valid.args",
-                        message: "nextToken 사용 시 데이터 일관성을 위해 최초 요청 시의 옵션(requestStartTime, requestEndTime, pageSize 등)이 모두 동일하게 유지되어야 합니다.",
-                    },
+                errors: [
+                    "nextToken 사용 시 데이터 일관성을 위해 최초 요청 시의 옵션이 모두 동일하게 유지되어야 합니다.",
+                    "requestStartTime, requestEndTime, pageSize 옵션을 확인해주세요.",
                 ],
             });
         }

package/dist-es/commands/ListSMSStatusCommand.js

@@ -13,14 +13,12 @@ class ListSMSStatusCommand extends index_js_1.SensCommand {
         super(input);
         if (input.nextToken && (!input.requestStartTime || !input.requestEndTime)) {
             throw new index_js_1.SensError({
-                code: 400,
-                type: "Bad Request",
+                code: -1,
+                type: "SDK.GENERAL_ERROR",
                 message: "페이지네이션 검색 조건 불일치",
-                invalidInputs: [
-                    {
-                        type: "not-valid.args",
-                        message: "nextToken 사용 시 데이터 일관성을 위해 최초 요청 시의 옵션(requestStartTime, requestEndTime, pageSize 등)이 모두 동일하게 유지되어야 합니다.",
-                    },
+                errors: [
+                    "nextToken 사용 시 데이터 일관성을 위해 최초 요청 시의 옵션이 모두 동일하게 유지되어야 합니다.",
+                    "requestStartTime, requestEndTime, pageSize 옵션을 확인해주세요.",
                 ],
             });
         }

package/dist-es/commands/SendAlimtalkCommand.js

@@ -22,24 +22,17 @@ exports.SendAlimtalkCommand = SendAlimtalkCommand;
 const resolveAlimtalkMessages = (messages, config) => {
     if (!messages.length || messages.length > config.maxRecipients) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
-            message: "알림톡 동시 발송 범위 오류",
-            invalidInputs: [
-                {
-                    type: "not-valid.args",
-                    message: `메세지 동시 발송은 최소 1명, 최대 ${config.maxRecipients}명까지 가능합니다.`,
-                },
-            ],
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
+            message: `알림톡 동시 발송은 최소 1명, 최대 ${config.maxRecipients}명까지 가능합니다.`,
         });
     }
     const result = messages.map((message) => {
         if (message.content.length > config.maxContentLength) {
             throw new index_js_1.SensError({
-                code: 400,
-                type: "Bad Request",
-                message: "알림톡 최대 길이 초과",
-                invalidInputs: [{ type: "not-valid.args", message: `메세지 최대 길이는 ${config.maxContentLength}글자입니다` }],
+                code: -1,
+                type: "SDK.GENERAL_ERROR",
+                message: `알림톡 최대 길이는 ${config.maxContentLength}글자입니다`,
             });
         }
         return {

package/dist-es/commands/SendMMSCommand.js

@@ -36,12 +36,9 @@ const resolveSendFile = (file, options) => {
     const ext = parsed.ext.toLocaleLowerCase();
     if (!options.supportExt.includes(ext)) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
-            message: "지원하지 않는 확장자입니다.",
-            invalidInputs: [
-                { type: "not-valid.args", message: `${options.supportExt.join(", ")} 형식의 첨부파일만 지원합니다.` },
-            ],
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
+            message: `MMS는 ${options.supportExt.join(", ")} 형식의 첨부파일만 보낼 수 있습니다.`,
         });
     }
     if (file.body) {
@@ -55,10 +52,9 @@ const resolveSendFile = (file, options) => {
     }
     if (!(0, node_fs_1.existsSync)(file.name)) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
-            message: "파일이 존재하지 않습니다.",
-            invalidInputs: [{ type: "not-valid.args", message: `${file.name} 파일이 존재하지 않습니다.` }],
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
+            message: `${file.name} 첨부파일이 존재하지 않습니다.`,
         });
     }
     const buffer = (0, node_fs_1.readFileSync)(file.name);
@@ -74,15 +70,9 @@ const checkSizeLimit = (buffer, maxKiB) => {
     const kibSize = Math.ceil(byteSize / 1024);
     if (kibSize > maxKiB) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
-            message: `최대 첨부가능 용량이 초과되었습니다.`,
-            invalidInputs: [
-                {
-                    type: "not-valid.args",
-                    message: `최대 ${maxKiB}KiB까지 전송 가능합니다. 현재 ${kibSize}KiB`,
-                },
-            ],
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
+            message: `첨부파일은 ${maxKiB}KiB까지 전송 가능합니다. 현재 ${kibSize}KiB`,
         });
     }
     return;

package/dist-es/commands/SendSMSCommand.js

@@ -47,18 +47,16 @@ const getMessageType = (input) => {
     const contentLength = (0, constants_1.getContentLength)(input.content);
     if (!contentLength) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
             message: "메세지 내용이 없습니다.",
-            invalidInputs: [{ type: "not-valid.args", message: "메세지 내용을 확인해주세요." }],
         });
     }
     if (contentLength > LMS_MAX_CONTENT_LENGTH) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
-            message: "메세지 최대 크기 초과",
-            invalidInputs: [{ type: "not-valid.args", message: `메세지 최대 길이는 ${LMS_MAX_CONTENT_LENGTH}글자입니다` }],
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
+            message: `메세지 최대 길이는 ${LMS_MAX_CONTENT_LENGTH}글자입니다`,
         });
     }
     return contentLength > SMS_MAX_CONTENT_LENGTH ? "LMS" : "SMS";

package/dist-es/commands/constants.js

@@ -42,28 +42,17 @@ const resolveRequestDuration = (input, config) => {
     const diff = end - start;
     if (diff < 0) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
-            message: `조회 가능 날짜 오류`,
-            invalidInputs: [
-                {
-                    type: "not-valid.args",
-                    message: "종료일이 시작일보다 빠를 수 없습니다.",
-                },
-            ],
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
+            message: "조회 가능 날짜 오류. 종료일이 시작일보다 빠를 수 없습니다.",
+            errors: [`종료일: ${input.endTime}`, `시작일: ${input.startTime}`],
         });
     }
     if (diff > config.durationLimitMs) {
         throw new index_js_1.SensError({
-            code: 400,
-            type: "Bad Request",
-            message: `조회 가능 날짜 범위 오류`,
-            invalidInputs: [
-                {
-                    type: "not-valid.args",
-                    message: `조회 가능한 날짜 범위는 최대 ${config.durationLimitMs / (24 * 3600000)}일 이내여야 합니다.`,
-                },
-            ],
+            code: -1,
+            type: "SDK.GENERAL_ERROR",
+            message: `최대 ${config.durationLimitMs / (24 * 3600000)}일 이내에서 조회 가능합니다.`,
         });
     }
     return {

package/dist-es/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./commands/index.js"), exports);
 __exportStar(require("./SensClient.js"), exports);
+__exportStar(require("./models/SensError.js"), exports);

package/dist-es/middleware/middleware-metadata.js

@@ -5,7 +5,7 @@ const constants_js_1 = require("./constants.js");
 const middlewareIngestkoreaMetadata = (next) => async (input, context) => {
     input.request.headers = {
         ...input.request.headers,
-        [constants_js_1.INGESTKOREA_USER_AGENT]: "@ingestkorea/client-sens/1.8.x",
+        [constants_js_1.INGESTKOREA_USER_AGENT]: "@ingestkorea/client-sens/1.10.x",
     };
     return next(input, context);
 };

package/dist-es/middleware/middleware-retry.js

@@ -1,60 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.middlewareRetry = void 0;
-const util_error_handler_1 = require("@ingestkorea/util-error-handler");
+const index_js_1 = require("../models/index.js");
 const constants_js_1 = require("./constants.js");
 const middlewareRetry = (next) => async (input, context) => {
-    var _a, _b;
-    var _c;
     const MAX_RETRIES = 3;
+    const MIN_DELAY_MS = 300;
     const BASE_DELAY_MS = 500;
     const MAX_DELAY_MS = 5000;
     let attempts = 0;
     let totalRetryDelay = 0;
-    (_a = (_c = input.request).headers) !== null && _a !== void 0 ? _a : (_c.headers = {});
-    let lastError = new util_error_handler_1.IngestkoreaError({
-        code: 400,
-        type: "Bad Request",
-        message: "Invalid Request",
-        description: { attempts, maxRetries: MAX_RETRIES, totalRetryDelay },
-    });
+    input.request.headers = {
+        ...input.request.headers,
+    };
     while (attempts < MAX_RETRIES) {
-        const attemptNo = attempts + 1;
-        const requestLog = `attempt=${attemptNo}; max=${MAX_RETRIES}; totalRetryDelay=${totalRetryDelay}`;
+        attempts++;
+        const requestLog = `attempt=${attempts}; max=${MAX_RETRIES}; totalRetryDelay=${totalRetryDelay}`;
         input.request.headers[constants_js_1.INGESTKOREA_REQUEST_LOG] = requestLog;
         try {
             const { response } = await next(input, context);
-            response.headers[constants_js_1.INGESTKOREA_RETRY] = attemptNo.toString();
+            response.headers[constants_js_1.INGESTKOREA_RETRY] = attempts.toString();
             response.headers[constants_js_1.INGESTKOREA_RETRY_DELAY] = totalRetryDelay.toString();
             return { response };
         }
         catch (error) {
-            attempts++;
-            lastError.error.description = { attempts, maxRetries: MAX_RETRIES, totalRetryDelay };
-            if (error instanceof util_error_handler_1.IngestkoreaError) {
-                lastError.error.description = {
-                    ...lastError.error.description,
-                    detail: error.error.description,
-                };
-            }
-            else {
-                lastError.error.description = {
-                    ...lastError.error.description,
-                    detail: String((_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : error),
-                };
-            }
             if (attempts >= MAX_RETRIES) {
-                lastError.error.description = { attempts, maxRetries: MAX_RETRIES, totalRetryDelay };
-                throw lastError;
+                throw new index_js_1.SensError({
+                    code: -1,
+                    type: "SDK.REQUEST_ERROR",
+                    message: error instanceof Error ? error.message : requestLog,
+                });
             }
             const exp = BASE_DELAY_MS * 2 ** (attempts - 1);
             const capped = Math.min(MAX_DELAY_MS, exp);
-            const delay = Math.floor(Math.random() * capped);
+            const baseWait = Math.max(MIN_DELAY_MS, Math.floor(capped / 2));
+            const jitter = Math.floor(Math.random() * (capped - baseWait));
+            const delay = baseWait + jitter;
             totalRetryDelay += delay;
-            lastError.error.description = { attempts, maxRetries: MAX_RETRIES, totalRetryDelay };
             await new Promise((resolve) => setTimeout(resolve, delay));
         }
     }
-    throw lastError;
+    throw new index_js_1.SensError({
+        code: -1,
+        type: "SDK.UNKNOWN_ERROR",
+        message: "Unexpected retry loop termination",
+    });
 };
 exports.middlewareRetry = middlewareRetry;

package/dist-es/models/SensError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensError = void 0;
+class SensError extends Error {
+    constructor(info) {
+        super(info.message);
+        this.name = "SensError";
+        this.code = info.code;
+        this.type = info.type;
+        this.errors = info.errors || [];
+        this.timestamp = new Date().toISOString();
+    }
+}
+exports.SensError = SensError;

package/dist-es/models/SensErrorInfo.js

@@ -1,13 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SensError = void 0;
-class SensError extends Error {
-    constructor(info) {
-        super(info.message);
-        this.name = "SensError";
-        this.code = info.code;
-        this.type = info.type;
-        this.invalidInputs = info.invalidInputs || [];
-    }
-}
-exports.SensError = SensError;
+exports.NCLOUD_ERROR_BODY_SPEC = exports.SENS_ERROR_BODY_SPEC = exports.NCLOUD_ERROR_CODE_SPEC = exports.SENS_ERROR_CODE_SPEC = void 0;
+exports.SENS_ERROR_CODE_SPEC = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+};
+exports.NCLOUD_ERROR_CODE_SPEC = {
+    "100": { status: 400, type: exports.SENS_ERROR_CODE_SPEC["400"] },
+    "200": { status: 401, type: exports.SENS_ERROR_CODE_SPEC["401"] },
+    "210": { status: 403, type: exports.SENS_ERROR_CODE_SPEC["403"] },
+    "300": { status: 404, type: exports.SENS_ERROR_CODE_SPEC["404"] },
+    "400": { status: 429, type: exports.SENS_ERROR_CODE_SPEC["429"] },
+    "410": { status: 429, type: exports.SENS_ERROR_CODE_SPEC["429"] },
+    "420": { status: 429, type: exports.SENS_ERROR_CODE_SPEC["429"] },
+    "900": { status: 500, type: exports.SENS_ERROR_CODE_SPEC["500"] },
+};
+exports.SENS_ERROR_BODY_SPEC = [
+    ["status", "number", true],
+    ["errorMessage", "string", false],
+    ["errors", "object", false],
+];
+exports.NCLOUD_ERROR_BODY_SPEC = [
+    ["errorCode", "string", true],
+    ["message", "string", false],
+    ["details", "string", false],
+];

package/dist-es/models/index.js

@@ -29,5 +29,6 @@ __exportStar(require("./SendMMS.js"), exports);
 __exportStar(require("./SendSMS.js"), exports);
 __exportStar(require("./SensClient.js"), exports);
 __exportStar(require("./SensCommand.js"), exports);
+__exportStar(require("./SensError.js"), exports);
 __exportStar(require("./SensErrorInfo.js"), exports);
 __exportStar(require("./SensMiddleware.js"), exports);

package/dist-es/protocols/constants.js

@@ -19,80 +19,84 @@ const parseBody = async (output) => {
     if (!isJsonResponse(headers["content-type"])) {
         await (0, util_http_handler_1.destroyStream)(streamBody);
         throw new index_js_1.SensError({
-            code: statusCode !== null && statusCode !== void 0 ? statusCode : 400,
-            type: "Bad Request",
+            code: -1,
+            type: "SDK.REQUEST_ERROR",
             message: "response content-type is not application/json",
         });
     }
-    const data = await (0, util_http_handler_1.collectBodyString)(streamBody);
-    if (data.length) {
-        try {
-            return JSON.parse(data);
-        }
-        catch (e) {
-            await (0, util_http_handler_1.destroyStream)(streamBody);
-            throw new index_js_1.SensError({
-                code: statusCode !== null && statusCode !== void 0 ? statusCode : 400,
-                type: "Bad Request",
-                message: "parse response body error",
-            });
-        }
+    try {
+        const data = await (0, util_http_handler_1.collectBodyString)(streamBody);
+        return data.length ? JSON.parse(data) : {};
+    }
+    catch (e) {
+        throw new index_js_1.SensError({
+            code: -1,
+            type: "SDK.REQUEST_ERROR",
+            message: e instanceof Error ? e.message : "parse response body error",
+        });
     }
-    return {};
 };
 exports.parseBody = parseBody;
 const parseErrorBody = async (output) => {
     const { statusCode, headers, body: streamBody } = output;
-    const error = new index_js_1.SensError({
-        code: statusCode !== null && statusCode !== void 0 ? statusCode : 400,
-        type: "Bad Request",
-        message: "something wrong",
-    });
     if (!isJsonResponse(headers["content-type"])) {
         await (0, util_http_handler_1.destroyStream)(streamBody);
-        error.message = "response content-type is not application/json";
-        throw error;
+        throw new index_js_1.SensError({
+            code: -1,
+            type: "SDK.REQUEST_ERROR",
+            message: "response content-type is not application/json",
+        });
     }
     const data = await (0, util_http_handler_1.collectBodyString)(streamBody);
-    await (0, util_http_handler_1.destroyStream)(streamBody);
-    const sensErrorBody = isSensErrorBody(data);
-    if (!sensErrorBody) {
-        throw error;
+    const sensErrorBody = isSensErrorResponse(data);
+    const nCloudErrorBody = isNCloudErrorResponse(data);
+    if (sensErrorBody) {
+        const errorType = isSensErrorCode(sensErrorBody.status)
+            ? index_js_1.SENS_ERROR_CODE_SPEC[sensErrorBody.status]
+            : "SDK.UNKNOWN_ERROR";
+        throw new index_js_1.SensError({
+            code: isSensErrorCode(sensErrorBody.status) ? sensErrorBody.status : statusCode,
+            type: errorType,
+            message: sensErrorBody.errorMessage || errorType,
+            ...(sensErrorBody.errors &&
+                Array.isArray(sensErrorBody.errors) && {
+                errors: sensErrorBody.errors.filter((d) => !!d),
+            }),
+        });
+    }
+    if (nCloudErrorBody) {
+        const { errorCode } = nCloudErrorBody.error;
+        const errorType = isNCloudErrorCode(errorCode)
+            ? index_js_1.NCLOUD_ERROR_CODE_SPEC[errorCode].type
+            : "SDK.UNKNOWN_ERROR";
+        throw new index_js_1.SensError({
+            code: isNCloudErrorCode(errorCode) ? index_js_1.NCLOUD_ERROR_CODE_SPEC[errorCode].status : statusCode,
+            type: errorType,
+            message: nCloudErrorBody.error.details || "Something wrong",
+        });
     }
     throw new index_js_1.SensError({
-        code: sensErrorBody.status,
-        type: SENS_ERROR_CODE_SPEC[sensErrorBody.status] || "Unknown Error",
-        message: sensErrorBody.errorMessage || "Something wrong",
-        ...(sensErrorBody.errors &&
-            Array.isArray(sensErrorBody.errors) && {
-            invalidInputs: sensErrorBody.errors.map((msg) => {
-                return { type: "not-valid.args", message: msg };
-            }),
-        }),
+        code: -1,
+        type: "SDK.UNKNOWN_ERROR",
+        message: "Invalid Naver Cloud Platform response format",
+        errors: [`${statusCode} - ${data.slice(0, 120)}...`],
     });
 };
 exports.parseErrorBody = parseErrorBody;
-const SENS_ERROR_CODE_SPEC = {
-    400: "Bad Request",
-    401: "Unauthorized",
-    403: "Forbidden",
-    404: "Not Found",
-    429: "Too Many Requests",
-    500: "Internal Server Error",
+const isSensErrorCode = (code) => {
+    return code in index_js_1.SENS_ERROR_CODE_SPEC;
+};
+const isNCloudErrorCode = (code) => {
+    return code in index_js_1.NCLOUD_ERROR_CODE_SPEC;
 };
-const SENS_ERROR_BODY_SPEC = [
-    ["status", "number", true],
-    ["errorMessage", "string", false],
-    ["errors", "object", false],
-];
-const isSensErrorBody = (input) => {
+const isSensErrorResponse = (input) => {
     if (typeof input !== "string")
         return null;
     try {
         const data = JSON.parse(input);
         if (!data || typeof data !== "object")
             return null;
-        const isValid = SENS_ERROR_BODY_SPEC.every(([key, type, required]) => {
+        const isValid = index_js_1.SENS_ERROR_BODY_SPEC.every(([key, type, required]) => {
             const value = data[key];
             if (required && (value === undefined || value === null))
                 return false;
@@ -106,6 +110,27 @@ const isSensErrorBody = (input) => {
         return null;
     }
 };
+const isNCloudErrorResponse = (input) => {
+    if (typeof input !== "string")
+        return null;
+    try {
+        const data = JSON.parse(input);
+        if (!(data && typeof data == "object" && typeof data.error == "object"))
+            return null;
+        const isValid = index_js_1.NCLOUD_ERROR_BODY_SPEC.every(([key, type, required]) => {
+            const value = data.error[key];
+            if (required && (value === undefined || value === null))
+                return false;
+            if (value !== undefined && typeof value !== type)
+                return false;
+            return true;
+        });
+        return isValid ? data : null;
+    }
+    catch (_a) {
+        return null;
+    }
+};
 const compact = (obj) => {
     if (Array.isArray(obj)) {
         return obj.map((item) => (0, exports.compact)(item));
@@ -125,5 +150,6 @@ const convertToUtc = (input) => {
 };
 exports.convertToUtc = convertToUtc;
 const isJsonResponse = (contentType) => {
-    return /application\/json/gi.exec(contentType || "") ? true : false;
+    var _a;
+    return (_a = contentType === null || contentType === void 0 ? void 0 : contentType.toLowerCase().includes("application/json")) !== null && _a !== void 0 ? _a : false;
 };

package/dist-types/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./commands/index.js";
 export * from "./SensClient.js";
+export * from "./models/SensError.js";

package/dist-types/models/SensClient.d.ts

@@ -4,7 +4,6 @@ export type Credentials = {
 };
 export type ServiceId = {
     kakao: string;
-    push: string;
     sms: string;
 };
 export interface SensClientConfig {

package/dist-types/models/SensError.d.ts

@@ -0,0 +1,17 @@
+import { SesnResponseErrorType } from "./SensErrorInfo.js";
+type SensClientErrorType = "SDK.AUTH_ERROR" | "SDK.GENERAL_ERROR" | "SDK.REQUEST_ERROR" | "SDK.UNKNOWN_ERROR";
+export type SensErrorType = SesnResponseErrorType | SensClientErrorType;
+export interface SensErrorInput {
+    code: number;
+    type: SensErrorType;
+    message: string;
+    errors?: string[];
+}
+export declare class SensError extends Error {
+    readonly code: number;
+    readonly type: SensErrorType;
+    readonly errors: string[];
+    readonly timestamp: string;
+    constructor(info: SensErrorInput);
+}
+export {};