@ingestkorea/client-sens 1.7.0 → 1.9.0

package/dist-es/protocols/constants.js

@@ -1,49 +1,129 @@
-import { IngestkoreaError, ingestkoreaErrorCodeChecker } from "@ingestkorea/util-error-handler";
-import { collectBodyString, destroyStream } from "@ingestkorea/util-http-handler";
-export const parseBody = async (output) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToUtc = exports.compact = exports.parseErrorBody = exports.parseBody = exports.deserializeMetadata = void 0;
+const util_http_handler_1 = require("@ingestkorea/util-http-handler");
+const index_js_1 = require("../models/index.js");
+const constants_js_1 = require("../middleware/constants.js");
+const deserializeMetadata = (response) => {
+    const attempts = response.headers[constants_js_1.INGESTKOREA_RETRY] || "1";
+    const totalRetryDelay = response.headers[constants_js_1.INGESTKOREA_RETRY_DELAY] || "0";
+    return {
+        httpStatusCode: response.statusCode,
+        attempts: Number(attempts),
+        totalRetryDelay: Number(totalRetryDelay),
+    };
+};
+exports.deserializeMetadata = deserializeMetadata;
+const parseBody = async (output) => {
     const { statusCode, headers, body: streamBody } = output;
-    const isValid = await verifyJsonHeader(headers["content-type"]);
-    if (!isValid) {
-        await destroyStream(streamBody);
-        let customError = new IngestkoreaError({
-            code: 400,
+    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",
-            message: "Invalid Request",
-            description: "content-type is not application/json",
+            message: "response content-type is not application/json",
         });
-        if (ingestkoreaErrorCodeChecker(statusCode))
-            customError.error.code = statusCode;
-        throw customError;
     }
-    const data = await collectBodyString(streamBody);
-    if (data.length)
-        return JSON.parse(data);
+    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",
+            });
+        }
+    }
     return {};
 };
-export const parseErrorBody = async (output) => {
+exports.parseBody = parseBody;
+const parseErrorBody = async (output) => {
     const { statusCode, headers, body: streamBody } = output;
-    const isValid = await verifyJsonHeader(headers["content-type"]);
-    await destroyStream(streamBody);
-    let customError = new IngestkoreaError({
-        code: 400,
+    const error = new index_js_1.SensError({
+        code: statusCode !== null && statusCode !== void 0 ? statusCode : 400,
         type: "Bad Request",
-        message: "Invalid Request",
-        description: "content-type is not application/json",
+        message: "something wrong",
     });
-    if (ingestkoreaErrorCodeChecker(statusCode))
-        customError.error.code = statusCode;
-    if (!isValid)
-        throw customError;
-    const data = await collectBodyString(streamBody);
-    if (data.length)
-        customError.error.description = JSON.parse(data);
-    throw customError;
-};
-const verifyJsonHeader = async (contentType) => {
-    return /application\/json/gi.exec(contentType) ? true : false;
-};
-export const deserializeMetadata = (response) => {
-    return {
-        httpStatusCode: response.statusCode,
-    };
+    if (!isJsonResponse(headers["content-type"])) {
+        await (0, util_http_handler_1.destroyStream)(streamBody);
+        error.message = "response content-type is not application/json";
+        throw error;
+    }
+    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;
+    }
+    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 };
+            }),
+        }),
+    });
+};
+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 SENS_ERROR_BODY_SPEC = [
+    ["status", "number", true],
+    ["errorMessage", "string", false],
+    ["errors", "object", false],
+];
+const isSensErrorBody = (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 value = data[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));
+    }
+    if (typeof obj === "object" && obj !== null) {
+        return Object.fromEntries(Object.entries(obj)
+            .filter(([_, value]) => value !== undefined) // undefined 필드 제거
+            .map(([key, value]) => [key, (0, exports.compact)(value)]) // 내부 값 재귀 처리
+        );
+    }
+    return obj;
+};
+exports.compact = compact;
+const convertToUtc = (input) => {
+    const utcRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
+    return utcRegex.test(input) ? input : new Date(input.replace(" ", "T") + "+09:00").toISOString();
+};
+exports.convertToUtc = convertToUtc;
+const isJsonResponse = (contentType) => {
+    return /application\/json/gi.exec(contentType || "") ? true : false;
 };

package/dist-types/SensClient.d.ts

@@ -1,25 +1,8 @@
-import { NodeHttpHandler } from "@ingestkorea/util-http-handler";
-import { SensCommand } from "./models";
-export type Credentials = {
-    accessKey: string;
-    secretKey: string;
-};
-export type ServiceId = {
-    push?: string;
-    sms?: string;
-    kakao?: string;
-};
-export interface SensClientConfig {
-    credentials?: Credentials;
-    serviceId?: ServiceId;
-}
-export interface SensClientResolvedConfig {
-    credentials: Credentials;
-    serviceId: ServiceId;
-}
+import { SensClientConfig, SensClientResolvedConfig, SensCommand } from "./models/index.js";
 export declare class SensClient {
     config: SensClientResolvedConfig;
-    requestHandler: NodeHttpHandler;
+    private httpHandler;
+    private requestHandler;
     constructor(config: SensClientConfig);
     send<T, P>(command: SensCommand<T, P, SensClientResolvedConfig>): Promise<P>;
 }

package/dist-types/commands/GetAlimtalkResultCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, GetAlimtalkResultInput, GetAlimtalkResultOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface GetAlimtalkResultCommandInput extends GetAlimtalkResultInput {
+import { SensClientResolvedConfig, SensCommand, GetAlimtalkResultRequest, GetAlimtalkResultResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface GetAlimtalkResultCommandInput extends GetAlimtalkResultRequest {
 }
-export interface GetAlimtalkResultCommandOutput extends GetAlimtalkResultOutput, MetadataBearer {
+export interface GetAlimtalkResultCommandOutput extends MetadataBearer, GetAlimtalkResultResult {
 }
 export declare class GetAlimtalkResultCommand extends SensCommand<GetAlimtalkResultCommandInput, GetAlimtalkResultCommandOutput, SensClientResolvedConfig> {
     input: GetAlimtalkResultCommandInput;
+    serializer: RequestSerializer<GetAlimtalkResultCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<GetAlimtalkResultCommandOutput, SensClientResolvedConfig>;
     constructor(input: GetAlimtalkResultCommandInput);
-    serialize(input: GetAlimtalkResultCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<GetAlimtalkResultCommandOutput>;
 }

package/dist-types/commands/GetAlimtalkStatusCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, GetAlimtalkStatusInput, GetAlimtalkStatusOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface GetAlimtalkStatusCommandInput extends GetAlimtalkStatusInput {
+import { SensClientResolvedConfig, SensCommand, GetAlimtalkStatusRequest, GetAlimtalkStatusResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface GetAlimtalkStatusCommandInput extends GetAlimtalkStatusRequest {
 }
-export interface GetAlimtalkStatusCommandOutput extends GetAlimtalkStatusOutput, MetadataBearer {
+export interface GetAlimtalkStatusCommandOutput extends MetadataBearer, GetAlimtalkStatusResult {
 }
 export declare class GetAlimtalkStatusCommand extends SensCommand<GetAlimtalkStatusCommandInput, GetAlimtalkStatusCommandOutput, SensClientResolvedConfig> {
     input: GetAlimtalkStatusCommandInput;
+    serializer: RequestSerializer<GetAlimtalkStatusCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<GetAlimtalkStatusCommandOutput, SensClientResolvedConfig>;
     constructor(input: GetAlimtalkStatusCommandInput);
-    serialize(input: GetAlimtalkStatusCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<GetAlimtalkStatusCommandOutput>;
 }

package/dist-types/commands/GetAlimtalkTemplateCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, GetAlimtalkTemplateInput, GetAlimtalkTemplateOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface GetAlimtalkTemplateCommandInput extends GetAlimtalkTemplateInput {
+import { SensClientResolvedConfig, SensCommand, GetAlimtalkTemplateRequest, GetAlimtalkTemplateResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface GetAlimtalkTemplateCommandInput extends GetAlimtalkTemplateRequest {
 }
-export interface GetAlimtalkTemplateCommandOutput extends GetAlimtalkTemplateOutput, MetadataBearer {
+export interface GetAlimtalkTemplateCommandOutput extends MetadataBearer, GetAlimtalkTemplateResult {
 }
 export declare class GetAlimtalkTemplateCommand extends SensCommand<GetAlimtalkTemplateCommandInput, GetAlimtalkTemplateCommandOutput, SensClientResolvedConfig> {
     input: GetAlimtalkTemplateCommandInput;
+    serializer: RequestSerializer<GetAlimtalkTemplateCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<GetAlimtalkTemplateCommandOutput, SensClientResolvedConfig>;
     constructor(input: GetAlimtalkTemplateCommandInput);
-    serialize(input: GetAlimtalkTemplateCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<GetAlimtalkTemplateCommandOutput>;
 }

package/dist-types/commands/GetSMSResultCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, GetSMSResultInput, GetSMSResultOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface GetSMSResultCommandInput extends GetSMSResultInput {
+import { SensClientResolvedConfig, SensCommand, GetSMSResultRequest, GetSMSResultResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface GetSMSResultCommandInput extends GetSMSResultRequest {
 }
-export interface GetSMSResultCommandOutput extends GetSMSResultOutput, MetadataBearer {
+export interface GetSMSResultCommandOutput extends MetadataBearer, GetSMSResultResult {
 }
 export declare class GetSMSResultCommand extends SensCommand<GetSMSResultCommandInput, GetSMSResultCommandOutput, SensClientResolvedConfig> {
     input: GetSMSResultCommandInput;
+    serializer: RequestSerializer<GetSMSResultCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<GetSMSResultCommandOutput, SensClientResolvedConfig>;
     constructor(input: GetSMSResultCommandInput);
-    serialize(input: GetSMSResultCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<GetSMSResultCommandOutput>;
 }

package/dist-types/commands/GetSMSStatusCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, GetSMSStatusInput, GetSMSStatusOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface GetSMSStatusCommandInput extends GetSMSStatusInput {
+import { SensClientResolvedConfig, SensCommand, GetSMSStatusRequest, GetSMSStatusResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface GetSMSStatusCommandInput extends GetSMSStatusRequest {
 }
-export interface GetSMSStatusCommandOutput extends GetSMSStatusOutput, MetadataBearer {
+export interface GetSMSStatusCommandOutput extends MetadataBearer, GetSMSStatusResult {
 }
 export declare class GetSMSStatusCommand extends SensCommand<GetSMSStatusCommandInput, GetSMSStatusCommandOutput, SensClientResolvedConfig> {
     input: GetSMSStatusCommandInput;
+    serializer: RequestSerializer<GetSMSStatusCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<GetSMSStatusCommandOutput, SensClientResolvedConfig>;
     constructor(input: GetSMSStatusCommandInput);
-    serialize(input: GetSMSStatusCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<GetSMSStatusCommandOutput>;
 }

package/dist-types/commands/ListAlimtalkChannelsCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, ListAlimtalkChannelsInput, ListAlimtalkChannelsOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface ListAlimtalkChannelsCommandInput extends ListAlimtalkChannelsInput {
+import { SensClientResolvedConfig, SensCommand, ListAlimtalkChannelsRequest, ListAlimtalkChannelsResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface ListAlimtalkChannelsCommandInput extends ListAlimtalkChannelsRequest {
 }
-export interface ListAlimtalkChannelsCommandOutput extends ListAlimtalkChannelsOutput, MetadataBearer {
+export interface ListAlimtalkChannelsCommandOutput extends MetadataBearer, ListAlimtalkChannelsResult {
 }
 export declare class ListAlimtalkChannelsCommand extends SensCommand<ListAlimtalkChannelsCommandInput, ListAlimtalkChannelsCommandOutput, SensClientResolvedConfig> {
     input: ListAlimtalkChannelsCommandInput;
+    serializer: RequestSerializer<ListAlimtalkChannelsCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<ListAlimtalkChannelsCommandOutput, SensClientResolvedConfig>;
     constructor(input: ListAlimtalkChannelsCommandInput);
-    serialize(input: ListAlimtalkChannelsCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<ListAlimtalkChannelsCommandOutput>;
 }

package/dist-types/commands/ListAlimtalkStatusCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, ListAlimtalkStatusInput, ListAlimtalkStatusOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface ListAlimtalkStatusCommandInput extends ListAlimtalkStatusInput {
+import { SensClientResolvedConfig, SensCommand, ListAlimtalkStatusRequest, ListAlimtalkStatusResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface ListAlimtalkStatusCommandInput extends ListAlimtalkStatusRequest {
 }
-export interface ListAlimtalkStatusCommandOutput extends ListAlimtalkStatusOutput, MetadataBearer {
+export interface ListAlimtalkStatusCommandOutput extends MetadataBearer, ListAlimtalkStatusResult {
 }
 export declare class ListAlimtalkStatusCommand extends SensCommand<ListAlimtalkStatusCommandInput, ListAlimtalkStatusCommandOutput, SensClientResolvedConfig> {
     input: ListAlimtalkStatusCommandInput;
+    serializer: RequestSerializer<ListAlimtalkStatusCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<ListAlimtalkStatusCommandOutput, SensClientResolvedConfig>;
     constructor(input: ListAlimtalkStatusCommandInput);
-    serialize(input: ListAlimtalkStatusCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<ListAlimtalkStatusCommandOutput>;
 }

package/dist-types/commands/ListAlimtalkTemplatesCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, ListAlimtalkTemplatesInput, ListAlimtalkTemplatesOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface ListAlimtalkTemplatesCommandInput extends ListAlimtalkTemplatesInput {
+import { SensClientResolvedConfig, SensCommand, ListAlimtalkTemplatesRequest, ListAlimtalkTemplatesResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface ListAlimtalkTemplatesCommandInput extends ListAlimtalkTemplatesRequest {
 }
-export interface ListAlimtalkTemplatesCommandOutput extends ListAlimtalkTemplatesOutput, MetadataBearer {
+export interface ListAlimtalkTemplatesCommandOutput extends MetadataBearer, ListAlimtalkTemplatesResult {
 }
 export declare class ListAlimtalkTemplatesCommand extends SensCommand<ListAlimtalkTemplatesCommandInput, ListAlimtalkTemplatesCommandOutput, SensClientResolvedConfig> {
     input: ListAlimtalkTemplatesCommandInput;
+    serializer: RequestSerializer<ListAlimtalkTemplatesCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<ListAlimtalkTemplatesCommandOutput, SensClientResolvedConfig>;
     constructor(input: ListAlimtalkTemplatesCommandInput);
-    serialize(input: ListAlimtalkTemplatesCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<ListAlimtalkTemplatesCommandOutput>;
 }

package/dist-types/commands/ListSMSStatusCommand.d.ts

@@ -0,0 +1,11 @@
+import { SensClientResolvedConfig, SensCommand, ListSMSStatusRequest, ListSMSStatusResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface ListSMSStatusCommandInput extends ListSMSStatusRequest {
+}
+export interface ListSMSStatusCommandOutput extends MetadataBearer, ListSMSStatusResult {
+}
+export declare class ListSMSStatusCommand extends SensCommand<ListSMSStatusCommandInput, ListSMSStatusCommandOutput, SensClientResolvedConfig> {
+    input: ListSMSStatusCommandInput;
+    serializer: RequestSerializer<ListSMSStatusCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<ListSMSStatusCommandOutput, SensClientResolvedConfig>;
+    constructor(input: ListSMSStatusCommandInput);
+}

package/dist-types/commands/SendAlimtalkCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, SendAlimtalkInput, SendAlimtalkOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface SendAlimtalkCommandInput extends SendAlimtalkInput {
+import { SensClientResolvedConfig, SensCommand, SendAlimtalkRequest, SendAlimtalkResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface SendAlimtalkCommandInput extends SendAlimtalkRequest {
 }
-export interface SendAlimtalkCommandOutput extends SendAlimtalkOutput, MetadataBearer {
+export interface SendAlimtalkCommandOutput extends MetadataBearer, SendAlimtalkResult {
 }
 export declare class SendAlimtalkCommand extends SensCommand<SendAlimtalkCommandInput, SendAlimtalkCommandOutput, SensClientResolvedConfig> {
     input: SendAlimtalkCommandInput;
+    serializer: RequestSerializer<SendAlimtalkCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<SendAlimtalkCommandOutput, SensClientResolvedConfig>;
     constructor(input: SendAlimtalkCommandInput);
-    serialize(input: SendAlimtalkCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<SendAlimtalkCommandOutput>;
 }

package/dist-types/commands/SendMMSCommand.d.ts

@@ -1,16 +1,11 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, SendMMSInput, SendMMSOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface SendMMSCommandInput extends SendMMSInput {
+import { SensClientResolvedConfig, SensCommand, SendMMSRequest, SendMMSResult, MetadataBearer, RequestSerializer, ResponseDeserializer } from "../models/index.js";
+export interface SendMMSCommandInput extends SendMMSRequest {
 }
-export interface SendMMSCommandOutput extends SendMMSOutput, MetadataBearer {
+export interface SendMMSCommandOutput extends MetadataBearer, SendMMSResult {
 }
 export declare class SendMMSCommand extends SensCommand<SendMMSCommandInput, SendMMSCommandOutput, SensClientResolvedConfig> {
     input: SendMMSCommandInput;
+    serializer: RequestSerializer<SendMMSCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<SendMMSCommandOutput, SensClientResolvedConfig>;
     constructor(input: SendMMSCommandInput);
-    serialize(input: SendMMSCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<SendMMSCommandOutput>;
 }

package/dist-types/commands/SendSMSCommand.d.ts

@@ -1,16 +1,15 @@
-import { HttpRequest, HttpResponse } from "@ingestkorea/util-http-handler";
-import { SensCommand, SendSMSInput, SendSMSOutput, MetadataBearer } from "../models";
-import { SensClientResolvedConfig } from "../SensClient";
-export interface SendSMSCommandInput extends SendSMSInput {
+import { SensClientResolvedConfig, SensCommand, SendSMSRequest, SendSMSResult, MetadataBearer, RequestSerializer, ResponseDeserializer, SMSMessage } from "../models/index.js";
+export interface SendSMSCommandInput extends SendSMSRequest {
 }
-export interface SendSMSCommandOutput extends SendSMSOutput, MetadataBearer {
+export interface SendSMSCommandOutput extends MetadataBearer, SendSMSResult {
 }
 export declare class SendSMSCommand extends SensCommand<SendSMSCommandInput, SendSMSCommandOutput, SensClientResolvedConfig> {
     input: SendSMSCommandInput;
+    serializer: RequestSerializer<SendSMSCommandInput, SensClientResolvedConfig>;
+    deserializer: ResponseDeserializer<SendSMSCommandOutput, SensClientResolvedConfig>;
     constructor(input: SendSMSCommandInput);
-    serialize(input: SendSMSCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
-    deserialize(response: {
-        response: HttpResponse;
-        output: MetadataBearer;
-    }): Promise<SendSMSCommandOutput>;
 }
+export declare const resolveInputMessages: (messages: SMSMessage[], config: {
+    defaultContent: string;
+    defaultSubject: string;
+}) => SMSMessage[];

package/dist-types/commands/constants.d.ts

@@ -1,11 +1,21 @@
-export declare const SMS_MAX = 90;
-export declare const LMS_MAX = 2000;
-export declare const MMS_FILE_MAX = 300;
 export declare const trimText: (input: string) => string;
 export declare const prettyPhoneNum: (input: string) => string;
 /** @returns content-length(euc-kr) */
 export declare const getContentLength: (input: string) => number;
-export declare const getRequestDuration: (input?: number) => {
+export declare const convertToUtc: (input: string) => string;
+export declare const convertToKst: (input: number) => string;
+export declare const getDefaultRequestDuration: (config: {
+    durationLimitMs: number;
+}) => {
     startTime: string;
     endTime: string;
 };
+export declare const resolveRequestDuration: (input: {
+    startTime: string;
+    endTime: string;
+}, config: {
+    durationLimitMs: number;
+}) => {
+    startTimeMs: number;
+    endTimeMs: number;
+};

package/dist-types/commands/index.d.ts

@@ -1,11 +1,12 @@
-export * from "./SendAlimtalkCommand";
-export * from "./GetAlimtalkStatusCommand";
-export * from "./GetAlimtalkResultCommand";
-export * from "./GetAlimtalkTemplateCommand";
-export * from "./ListAlimtalkStatusCommand";
-export * from "./ListAlimtalkTemplatesCommand";
-export * from "./ListAlimtalkChannelsCommand";
-export * from "./SendSMSCommand";
-export * from "./SendMMSCommand";
-export * from "./GetSMSStatusCommand";
-export * from "./GetSMSResultCommand";
+export * from "./GetAlimtalkResultCommand.js";
+export * from "./GetAlimtalkStatusCommand.js";
+export * from "./GetAlimtalkTemplateCommand.js";
+export * from "./GetSMSResultCommand.js";
+export * from "./GetSMSStatusCommand.js";
+export * from "./ListAlimtalkChannelsCommand.js";
+export * from "./ListAlimtalkStatusCommand.js";
+export * from "./ListAlimtalkTemplatesCommand.js";
+export * from "./ListSMSStatusCommand.js";
+export * from "./SendAlimtalkCommand.js";
+export * from "./SendMMSCommand.js";
+export * from "./SendSMSCommand.js";

package/dist-types/index.d.ts

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

package/dist-types/middleware/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const INGESTKOREA_USER_AGENT = "x-ingestkorea-user-agent";
+export declare const INGESTKOREA_REQUEST_LOG = "x-ingestkorea-request";
+export declare const INGESTKOREA_RETRY = "x-ingestkorea-attempts";
+export declare const INGESTKOREA_RETRY_DELAY = "x-ingestkorea-total-retry-delay";
+export declare const NCP_ACCESS_KEY = "x-ncp-iam-access-key";
+export declare const NCP_TIMESTAMP = "x-ncp-apigw-timestamp";
+export declare const NCP_SIGNATURE = "x-ncp-apigw-signature-v2";

package/dist-types/middleware/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./middleware-sign";
-export * from "./middleware-metadata";
-export * from "./middleware-retry";
-export * from "./middleware-sort-headers";
+export * from "./middleware-metadata.js";
+export * from "./middleware-retry.js";
+export * from "./middleware-sign.js";

package/dist-types/middleware/middleware-metadata.d.ts

@@ -1,2 +1,2 @@
-import { BuildMiddleware } from "../models";
-export declare const middlewareIngestkoreaMetadata: BuildMiddleware;
+import { Middleware } from "../models/index.js";
+export declare const middlewareIngestkoreaMetadata: Middleware;

package/dist-types/middleware/middleware-retry.d.ts

@@ -1,2 +1,2 @@
-import { DeserializeMiddleware } from "../models";
-export declare const middlewareRetry: DeserializeMiddleware;
+import { Middleware } from "../models/index.js";
+export declare const middlewareRetry: Middleware;

package/dist-types/middleware/middleware-sign.d.ts

@@ -1,2 +1,2 @@
-import { BuildMiddleware } from "../models";
-export declare const middlewareNcpSigner: BuildMiddleware;
+import { Middleware } from "../models/index.js";
+export declare const middlewareNcpSign: Middleware;

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

@@ -1,8 +1,8 @@
-import { StatusMessage } from "./GetAlimtalkStatus";
-export interface GetAlimtalkResultInput {
+import { AlimtalkMessageStatus } from "./GetAlimtalkStatus.js";
+export interface GetAlimtalkResultRequest {
     messageId: string;
 }
-export interface GetAlimtalkResultOutput extends StatusMessage {
+export interface GetAlimtalkResultResult extends AlimtalkMessageStatus {
     failover?: Failover;
 }
 export interface Failover {

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

@@ -1,18 +1,21 @@
-import { ReceivedMessage } from "./SendAlimtalk";
-export interface GetAlimtalkStatusInput {
+import { AlimtalkMessageRequestStatus } from "./SendAlimtalk.js";
+export interface GetAlimtalkStatusRequest {
     requestId: string;
+    pageSize?: number;
+    nextToken?: string;
 }
-export interface GetAlimtalkStatusOutput {
+export interface GetAlimtalkStatusResult {
     requestId?: string;
     statusCode?: string;
     statusName?: string;
-    messages?: StatusMessage[];
+    messages?: AlimtalkMessageStatus[];
     pageSize?: number;
     pageIndex?: number;
     itemCount?: number;
     hasMore?: boolean;
+    nextToken?: string;
 }
-export interface StatusMessage extends ReceivedMessage {
+export interface AlimtalkMessageStatus extends AlimtalkMessageRequestStatus {
     requestId?: string;
     requestTime?: string;
     plusFriendId?: string;