@koreaaitel/sdk 0.0.0-stage → 0.62.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +943 -2
- package/dist/agent/index.cjs +5512 -0
- package/dist/agent/index.cjs.map +1 -0
- package/dist/agent/index.d.cts +1574 -0
- package/dist/agent/index.d.ts +1574 -0
- package/dist/agent/index.js +5402 -0
- package/dist/agent/index.js.map +1 -0
- package/dist/agent/livekit/index.cjs +675 -0
- package/dist/agent/livekit/index.cjs.map +1 -0
- package/dist/agent/livekit/index.d.cts +165 -0
- package/dist/agent/livekit/index.d.ts +165 -0
- package/dist/agent/livekit/index.js +669 -0
- package/dist/agent/livekit/index.js.map +1 -0
- package/dist/chunk-35XJNMFU.js +10 -0
- package/dist/chunk-35XJNMFU.js.map +1 -0
- package/dist/chunk-B3QB5WPI.cjs +202 -0
- package/dist/chunk-B3QB5WPI.cjs.map +1 -0
- package/dist/chunk-I7N2GTBL.js +6 -0
- package/dist/chunk-I7N2GTBL.js.map +1 -0
- package/dist/chunk-LLPMUDNE.cjs +16 -0
- package/dist/chunk-LLPMUDNE.cjs.map +1 -0
- package/dist/chunk-PDE4I4MV.cjs +1134 -0
- package/dist/chunk-PDE4I4MV.cjs.map +1 -0
- package/dist/chunk-T4ZQXFTN.js +181 -0
- package/dist/chunk-T4ZQXFTN.js.map +1 -0
- package/dist/chunk-TCIIGMEU.cjs +8 -0
- package/dist/chunk-TCIIGMEU.cjs.map +1 -0
- package/dist/chunk-ZFBHUDJB.js +1103 -0
- package/dist/chunk-ZFBHUDJB.js.map +1 -0
- package/dist/client-CrTIZPmY.d.cts +3074 -0
- package/dist/client-DJApW4Uf.d.ts +3074 -0
- package/dist/error-D1uHhe6r.d.cts +205 -0
- package/dist/error-D1uHhe6r.d.ts +205 -0
- package/dist/index.cjs +1741 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +22 -0
- package/dist/index.d.ts +22 -0
- package/dist/index.js +1638 -0
- package/dist/index.js.map +1 -0
- package/dist/media-profile-DZCqLJKa.d.cts +492 -0
- package/dist/media-profile-DZCqLJKa.d.ts +492 -0
- package/dist/solapi/index.cjs +684 -0
- package/dist/solapi/index.cjs.map +1 -0
- package/dist/solapi/index.d.cts +282 -0
- package/dist/solapi/index.d.ts +282 -0
- package/dist/solapi/index.js +673 -0
- package/dist/solapi/index.js.map +1 -0
- package/package.json +121 -4
package/dist/index.cjs
ADDED
|
@@ -0,0 +1,1741 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
Object.defineProperty(exports, '__esModule', { value: true });
|
|
4
|
+
|
|
5
|
+
var chunkLLPMUDNE_cjs = require('./chunk-LLPMUDNE.cjs');
|
|
6
|
+
var chunkB3QB5WPI_cjs = require('./chunk-B3QB5WPI.cjs');
|
|
7
|
+
var chunkTCIIGMEU_cjs = require('./chunk-TCIIGMEU.cjs');
|
|
8
|
+
var zod = require('zod');
|
|
9
|
+
var crypto = require('crypto');
|
|
10
|
+
|
|
11
|
+
// src/base-client.ts
|
|
12
|
+
var LOCALHOST_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "[::1]"]);
|
|
13
|
+
function validateBaseUrl(url) {
|
|
14
|
+
let parsed;
|
|
15
|
+
try {
|
|
16
|
+
parsed = new URL(url);
|
|
17
|
+
} catch {
|
|
18
|
+
throw new chunkB3QB5WPI_cjs.ClawOpsError(`Invalid base_url: ${url}`);
|
|
19
|
+
}
|
|
20
|
+
if (parsed.protocol === "https:") return url;
|
|
21
|
+
if (parsed.protocol === "http:" && LOCALHOST_HOSTS.has(parsed.hostname)) return url;
|
|
22
|
+
throw new chunkB3QB5WPI_cjs.ClawOpsError(
|
|
23
|
+
`base_url\uC740 HTTPS\uB97C \uC0AC\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4 (\uBC1B\uC740 \uAC12: '${url}'). \uB85C\uCEEC \uAC1C\uBC1C \uC2DC\uC5D0\uB294 http://localhost\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`
|
|
24
|
+
);
|
|
25
|
+
}
|
|
26
|
+
function serializeBody(body) {
|
|
27
|
+
if (body instanceof FormData) return { payload: body, contentType: null };
|
|
28
|
+
if (!body) return { payload: void 0, contentType: "application/json" };
|
|
29
|
+
return { payload: JSON.stringify(body), contentType: "application/json" };
|
|
30
|
+
}
|
|
31
|
+
var APIClient = class {
|
|
32
|
+
_apiKey;
|
|
33
|
+
_baseURL;
|
|
34
|
+
_maxRetries;
|
|
35
|
+
_timeout;
|
|
36
|
+
_fetch;
|
|
37
|
+
_defaultHeaders;
|
|
38
|
+
constructor(options) {
|
|
39
|
+
this._apiKey = options.apiKey;
|
|
40
|
+
this._baseURL = validateBaseUrl((options.baseURL ?? chunkLLPMUDNE_cjs.DEFAULT_BASE_URL).replace(/\/+$/, ""));
|
|
41
|
+
this._maxRetries = options.maxRetries ?? chunkLLPMUDNE_cjs.DEFAULT_MAX_RETRIES;
|
|
42
|
+
this._timeout = options.timeout ?? chunkLLPMUDNE_cjs.DEFAULT_TIMEOUT;
|
|
43
|
+
this._fetch = options.fetch ?? globalThis.fetch;
|
|
44
|
+
this._defaultHeaders = options.defaultHeaders ?? {};
|
|
45
|
+
}
|
|
46
|
+
_buildHeaders(extra) {
|
|
47
|
+
const headers = {
|
|
48
|
+
Authorization: `Bearer ${this._apiKey}`,
|
|
49
|
+
"Content-Type": "application/json",
|
|
50
|
+
Accept: "application/json",
|
|
51
|
+
"User-Agent": `claw-ops-node/${chunkTCIIGMEU_cjs.VERSION}`,
|
|
52
|
+
...this._defaultHeaders
|
|
53
|
+
};
|
|
54
|
+
if (extra) Object.assign(headers, extra);
|
|
55
|
+
return headers;
|
|
56
|
+
}
|
|
57
|
+
async _send(method2, path, options = {}) {
|
|
58
|
+
const headers = this._buildHeaders(options.extraHeaders);
|
|
59
|
+
const { payload, contentType } = serializeBody(options.body);
|
|
60
|
+
if (contentType === null) delete headers["Content-Type"];
|
|
61
|
+
else headers["Content-Type"] = contentType;
|
|
62
|
+
const params = new URLSearchParams();
|
|
63
|
+
const queryObj = { ...options.query, ...options.extraQuery };
|
|
64
|
+
for (const [k, v] of Object.entries(queryObj)) {
|
|
65
|
+
if (v != null) params.set(k, String(v));
|
|
66
|
+
}
|
|
67
|
+
const queryString = params.toString();
|
|
68
|
+
const url = `${this._baseURL}${path}${queryString ? `?${queryString}` : ""}`;
|
|
69
|
+
const reqTimeout = options.timeout ?? this._timeout;
|
|
70
|
+
let retriesLeft = this._maxRetries;
|
|
71
|
+
while (true) {
|
|
72
|
+
const controller = new AbortController();
|
|
73
|
+
const timeoutId = setTimeout(() => controller.abort(), reqTimeout);
|
|
74
|
+
let response;
|
|
75
|
+
try {
|
|
76
|
+
response = await this._fetch(url, {
|
|
77
|
+
method: method2,
|
|
78
|
+
headers,
|
|
79
|
+
body: payload,
|
|
80
|
+
signal: controller.signal
|
|
81
|
+
});
|
|
82
|
+
} catch (err) {
|
|
83
|
+
clearTimeout(timeoutId);
|
|
84
|
+
if (err instanceof DOMException && err.name === "AbortError") {
|
|
85
|
+
if (retriesLeft > 0) {
|
|
86
|
+
retriesLeft--;
|
|
87
|
+
await this._sleep(this._retryDelay(this._maxRetries - retriesLeft));
|
|
88
|
+
continue;
|
|
89
|
+
}
|
|
90
|
+
throw new chunkB3QB5WPI_cjs.APITimeoutError({ method: method2, url });
|
|
91
|
+
}
|
|
92
|
+
if (retriesLeft > 0) {
|
|
93
|
+
retriesLeft--;
|
|
94
|
+
await this._sleep(this._retryDelay(this._maxRetries - retriesLeft));
|
|
95
|
+
continue;
|
|
96
|
+
}
|
|
97
|
+
throw new chunkB3QB5WPI_cjs.APIConnectionError({ method: method2, url });
|
|
98
|
+
} finally {
|
|
99
|
+
clearTimeout(timeoutId);
|
|
100
|
+
}
|
|
101
|
+
if (response.ok) return response;
|
|
102
|
+
if (retriesLeft > 0 && this._shouldRetry(response.status)) {
|
|
103
|
+
retriesLeft--;
|
|
104
|
+
await this._sleep(this._retryDelay(this._maxRetries - retriesLeft));
|
|
105
|
+
continue;
|
|
106
|
+
}
|
|
107
|
+
let body;
|
|
108
|
+
try {
|
|
109
|
+
body = await response.json();
|
|
110
|
+
} catch {
|
|
111
|
+
body = null;
|
|
112
|
+
}
|
|
113
|
+
throw chunkB3QB5WPI_cjs.makeStatusError(response.status, body, response.headers, { method: method2, url });
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
async _request(method2, path, options = {}) {
|
|
117
|
+
const response = await this._send(method2, path, options);
|
|
118
|
+
if (response.status === 204 || !options.castTo) return null;
|
|
119
|
+
const url = `${this._baseURL}${path}`;
|
|
120
|
+
let json;
|
|
121
|
+
try {
|
|
122
|
+
json = await response.json();
|
|
123
|
+
} catch {
|
|
124
|
+
throw new chunkB3QB5WPI_cjs.APIResponseValidationError({ status: response.status }, { method: method2, url });
|
|
125
|
+
}
|
|
126
|
+
const parsed = options.castTo.safeParse(json);
|
|
127
|
+
if (!parsed.success) {
|
|
128
|
+
throw new chunkB3QB5WPI_cjs.APIResponseValidationError({ status: response.status }, { method: method2, url });
|
|
129
|
+
}
|
|
130
|
+
return parsed.data;
|
|
131
|
+
}
|
|
132
|
+
_shouldRetry(status) {
|
|
133
|
+
return status === 408 || status === 409 || status === 429 || status >= 500;
|
|
134
|
+
}
|
|
135
|
+
_retryDelay(retriesTaken) {
|
|
136
|
+
const delay = Math.min(chunkLLPMUDNE_cjs.INITIAL_RETRY_DELAY * 2 ** retriesTaken, chunkLLPMUDNE_cjs.MAX_RETRY_DELAY);
|
|
137
|
+
return delay * (1 + Math.random());
|
|
138
|
+
}
|
|
139
|
+
_sleep(ms) {
|
|
140
|
+
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
141
|
+
}
|
|
142
|
+
async _get(path, options) {
|
|
143
|
+
const result = await this._request(method("GET"), path, options);
|
|
144
|
+
return result;
|
|
145
|
+
}
|
|
146
|
+
async _post(path, options) {
|
|
147
|
+
const result = await this._request("POST", path, options);
|
|
148
|
+
return result;
|
|
149
|
+
}
|
|
150
|
+
async _put(path, options) {
|
|
151
|
+
const result = await this._request("PUT", path, options);
|
|
152
|
+
return result;
|
|
153
|
+
}
|
|
154
|
+
async _patch(path, options) {
|
|
155
|
+
const result = await this._request("PATCH", path, options);
|
|
156
|
+
return result;
|
|
157
|
+
}
|
|
158
|
+
async _getRaw(path, options = {}) {
|
|
159
|
+
return this._send("GET", path, options);
|
|
160
|
+
}
|
|
161
|
+
/**
|
|
162
|
+
* 본문을 돌려주는 DELETE. 기존 `_delete` 는 void 라 응답을 버리는데, soft delete 처럼
|
|
163
|
+
* 삭제 결과 리소스를 그대로 반환하는 endpoint 가 있어서 따로 둔다.
|
|
164
|
+
*/
|
|
165
|
+
async _deleteWithResponse(path, options) {
|
|
166
|
+
const result = await this._request("DELETE", path, options);
|
|
167
|
+
return result;
|
|
168
|
+
}
|
|
169
|
+
async _delete(path, options = {}) {
|
|
170
|
+
await this._request("DELETE", path, options);
|
|
171
|
+
}
|
|
172
|
+
};
|
|
173
|
+
function method(m) {
|
|
174
|
+
return m;
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
// src/resource.ts
|
|
178
|
+
var APIResource = class {
|
|
179
|
+
_client;
|
|
180
|
+
_accountId;
|
|
181
|
+
constructor(client, accountId) {
|
|
182
|
+
this._client = client;
|
|
183
|
+
this._accountId = accountId;
|
|
184
|
+
}
|
|
185
|
+
get _basePath() {
|
|
186
|
+
return `/v1/accounts/${this._accountId}`;
|
|
187
|
+
}
|
|
188
|
+
};
|
|
189
|
+
|
|
190
|
+
// src/util.ts
|
|
191
|
+
function stripNotGiven(data) {
|
|
192
|
+
const result = {};
|
|
193
|
+
for (const [k, v] of Object.entries(data)) {
|
|
194
|
+
if (v != null) {
|
|
195
|
+
result[k] = v;
|
|
196
|
+
}
|
|
197
|
+
}
|
|
198
|
+
return result;
|
|
199
|
+
}
|
|
200
|
+
var PaginationMetaSchema = zod.z.object({
|
|
201
|
+
total: zod.z.number(),
|
|
202
|
+
page: zod.z.number(),
|
|
203
|
+
pageSize: zod.z.number()
|
|
204
|
+
}).passthrough();
|
|
205
|
+
|
|
206
|
+
// src/pagination.ts
|
|
207
|
+
function PageSchema(itemSchema) {
|
|
208
|
+
return zod.z.object({
|
|
209
|
+
data: zod.z.array(itemSchema),
|
|
210
|
+
meta: PaginationMetaSchema
|
|
211
|
+
}).passthrough();
|
|
212
|
+
}
|
|
213
|
+
var Page = class _Page {
|
|
214
|
+
data;
|
|
215
|
+
meta;
|
|
216
|
+
_client = null;
|
|
217
|
+
_path = "";
|
|
218
|
+
_itemSchema = null;
|
|
219
|
+
_query = {};
|
|
220
|
+
constructor(data, meta) {
|
|
221
|
+
this.data = data;
|
|
222
|
+
this.meta = meta;
|
|
223
|
+
}
|
|
224
|
+
/** @internal */
|
|
225
|
+
_setClient(client, path, itemSchema, query) {
|
|
226
|
+
this._client = client;
|
|
227
|
+
this._path = path;
|
|
228
|
+
this._itemSchema = itemSchema;
|
|
229
|
+
this._query = query;
|
|
230
|
+
}
|
|
231
|
+
hasNextPage() {
|
|
232
|
+
return (this.meta.page + 1) * this.meta.pageSize < this.meta.total;
|
|
233
|
+
}
|
|
234
|
+
async nextPage() {
|
|
235
|
+
if (!this._client || !this._itemSchema) {
|
|
236
|
+
throw new Error("Page client is not set");
|
|
237
|
+
}
|
|
238
|
+
if (!this.hasNextPage()) {
|
|
239
|
+
throw new Error("No more pages");
|
|
240
|
+
}
|
|
241
|
+
const nextQuery = { ...this._query, page: this.meta.page + 1 };
|
|
242
|
+
const schema = PageSchema(this._itemSchema);
|
|
243
|
+
const raw = await this._client._get(this._path, {
|
|
244
|
+
castTo: schema,
|
|
245
|
+
query: nextQuery
|
|
246
|
+
});
|
|
247
|
+
const page = new _Page(raw.data, raw.meta);
|
|
248
|
+
page._setClient(this._client, this._path, this._itemSchema, this._query);
|
|
249
|
+
return page;
|
|
250
|
+
}
|
|
251
|
+
[Symbol.iterator]() {
|
|
252
|
+
return this.data[Symbol.iterator]();
|
|
253
|
+
}
|
|
254
|
+
async *autoPagingIter() {
|
|
255
|
+
let page = this;
|
|
256
|
+
while (true) {
|
|
257
|
+
for (const item of page.data) {
|
|
258
|
+
yield item;
|
|
259
|
+
}
|
|
260
|
+
if (!page.hasNextPage()) break;
|
|
261
|
+
page = await page.nextPage();
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
};
|
|
265
|
+
var AssignmentLinkAssignmentSchema = zod.z.object({
|
|
266
|
+
number: zod.z.string(),
|
|
267
|
+
name: zod.z.string().nullable().optional(),
|
|
268
|
+
consumedAt: zod.z.string(),
|
|
269
|
+
releasedAt: zod.z.string().nullable().optional()
|
|
270
|
+
}).passthrough();
|
|
271
|
+
var AssignmentLinkSchema = zod.z.object({
|
|
272
|
+
linkId: zod.z.string(),
|
|
273
|
+
url: zod.z.string(),
|
|
274
|
+
status: zod.z.enum(["pending", "consumed", "expired", "revoked"]),
|
|
275
|
+
createdAt: zod.z.string(),
|
|
276
|
+
expiresAt: zod.z.string(),
|
|
277
|
+
consumedAt: zod.z.string().nullable().optional(),
|
|
278
|
+
webhookUrl: zod.z.string().nullable().optional(),
|
|
279
|
+
webhookMethod: zod.z.enum(["POST", "GET"]).nullable().optional(),
|
|
280
|
+
note: zod.z.string().nullable().optional(),
|
|
281
|
+
assignment: AssignmentLinkAssignmentSchema.nullable().optional()
|
|
282
|
+
}).passthrough();
|
|
283
|
+
var AssignmentLinkCreateResponseSchema = zod.z.object({
|
|
284
|
+
token: zod.z.string(),
|
|
285
|
+
url: zod.z.string(),
|
|
286
|
+
expiresAt: zod.z.string()
|
|
287
|
+
}).passthrough();
|
|
288
|
+
|
|
289
|
+
// src/resources/assignment-links.ts
|
|
290
|
+
var AssignmentLinks = class extends APIResource {
|
|
291
|
+
async create(params = {}, options = {}) {
|
|
292
|
+
const body = stripNotGiven({
|
|
293
|
+
webhookUrl: params.webhookUrl,
|
|
294
|
+
webhookMethod: params.webhookMethod,
|
|
295
|
+
note: params.note
|
|
296
|
+
});
|
|
297
|
+
return this._client._post(`${this._basePath}/assignment-links`, {
|
|
298
|
+
body: Object.keys(body).length ? body : void 0,
|
|
299
|
+
castTo: AssignmentLinkCreateResponseSchema,
|
|
300
|
+
...options
|
|
301
|
+
});
|
|
302
|
+
}
|
|
303
|
+
async list(params = {}, options = {}) {
|
|
304
|
+
const query = stripNotGiven({
|
|
305
|
+
status: params.status,
|
|
306
|
+
page: params.page,
|
|
307
|
+
pageSize: params.pageSize
|
|
308
|
+
});
|
|
309
|
+
const path = `${this._basePath}/assignment-links`;
|
|
310
|
+
const schema = PageSchema(AssignmentLinkSchema);
|
|
311
|
+
const raw = await this._client._get(path, {
|
|
312
|
+
castTo: schema,
|
|
313
|
+
query: Object.keys(query).length ? query : void 0,
|
|
314
|
+
...options
|
|
315
|
+
});
|
|
316
|
+
const page = new Page(raw.data, raw.meta);
|
|
317
|
+
page._setClient(this._client, path, AssignmentLinkSchema, query);
|
|
318
|
+
return page;
|
|
319
|
+
}
|
|
320
|
+
async retrieve(linkId, options = {}) {
|
|
321
|
+
return this._client._get(`${this._basePath}/assignment-links/${linkId}`, {
|
|
322
|
+
castTo: AssignmentLinkSchema,
|
|
323
|
+
...options
|
|
324
|
+
});
|
|
325
|
+
}
|
|
326
|
+
async revoke(linkId, options = {}) {
|
|
327
|
+
await this._client._delete(
|
|
328
|
+
`${this._basePath}/assignment-links/${linkId}`,
|
|
329
|
+
options
|
|
330
|
+
);
|
|
331
|
+
}
|
|
332
|
+
};
|
|
333
|
+
var BlockedRecipientSchema = zod.z.object({
|
|
334
|
+
id: zod.z.string(),
|
|
335
|
+
/**
|
|
336
|
+
* 수신거부한 상대. **채널과 무관하게 항상 이 칸에 들어갑니다** —
|
|
337
|
+
* `call`·`message` 면 국내 표기로 정규화된 전화번호(예 `'01012345678'`),
|
|
338
|
+
* `email` 이면 소문자로 정규화된 이메일 주소(예 `'kim@example.com'`).
|
|
339
|
+
*
|
|
340
|
+
* 채널이 늘어도 이 칸 하나만 읽으면 됩니다.
|
|
341
|
+
*/
|
|
342
|
+
recipient: zod.z.string(),
|
|
343
|
+
/**
|
|
344
|
+
* ⚠️ `email` 이 2026-09-07 에 추가됐습니다. 이 값을 **enum 으로 좁히지 마세요** —
|
|
345
|
+
* 서버가 채널을 늘리면 옛 SDK 가 파싱 단계에서 통째로 실패합니다. 실제로 그 일이
|
|
346
|
+
* 있었습니다: `['call','message']` 로 굳혀 둔 탓에, 이메일 항목이 하나라도 섞이면
|
|
347
|
+
* 목록 조회 전체가 깨졌습니다. 알려진 값은 `BlockedChannel` 로 노출하되 파싱은
|
|
348
|
+
* 열어 둡니다.
|
|
349
|
+
*/
|
|
350
|
+
channel: zod.z.string(),
|
|
351
|
+
/** 지금 차단 중인지. 해제분도 이력으로 조회되므로 이 값으로 구분한다. */
|
|
352
|
+
active: zod.z.boolean(),
|
|
353
|
+
source: zod.z.string(),
|
|
354
|
+
sourceRef: zod.z.string().nullable().optional(),
|
|
355
|
+
note: zod.z.string().nullable().optional(),
|
|
356
|
+
createdBy: zod.z.string().nullable().optional(),
|
|
357
|
+
createdAt: zod.z.string(),
|
|
358
|
+
updatedAt: zod.z.string(),
|
|
359
|
+
unblockedAt: zod.z.string().nullable().optional(),
|
|
360
|
+
unblockedSource: zod.z.string().nullable().optional(),
|
|
361
|
+
unblockedBy: zod.z.string().nullable().optional(),
|
|
362
|
+
unblockedNote: zod.z.string().nullable().optional()
|
|
363
|
+
}).passthrough();
|
|
364
|
+
|
|
365
|
+
// src/resources/blocked-recipients.ts
|
|
366
|
+
var BlockedRecipients = class extends APIResource {
|
|
367
|
+
/**
|
|
368
|
+
* 수신거부 명단에 등록합니다.
|
|
369
|
+
*
|
|
370
|
+
* `recipient` 의 형식은 `channel` 이 정합니다 — `call`·`message` 는 **전화번호**(하이픈·`+82`
|
|
371
|
+
* 표기 모두 허용, 국내 표기로 정규화되어 저장), `email` 은 **이메일 주소**(소문자로 정규화).
|
|
372
|
+
*
|
|
373
|
+
* **멱등입니다** — 이미 차단 중인 (대상, 채널)을 다시 등록해도 에러가 아니라 기존 항목을
|
|
374
|
+
* 돌려줍니다. 같은 사람이 수신거부를 두 번 요청하는 것은 정상 상황이기 때문입니다.
|
|
375
|
+
*/
|
|
376
|
+
async create(params, options = {}) {
|
|
377
|
+
const body = stripNotGiven({
|
|
378
|
+
recipient: params.recipient,
|
|
379
|
+
channel: params.channel,
|
|
380
|
+
source: params.source,
|
|
381
|
+
sourceRef: params.sourceRef,
|
|
382
|
+
note: params.note
|
|
383
|
+
});
|
|
384
|
+
return this._client._post(`${this._basePath}/blocked-recipients`, {
|
|
385
|
+
body,
|
|
386
|
+
castTo: BlockedRecipientSchema,
|
|
387
|
+
...options
|
|
388
|
+
});
|
|
389
|
+
}
|
|
390
|
+
/**
|
|
391
|
+
* 수신거부 목록을 조회합니다. 기본은 **현재 차단 중인 항목만** 이며,
|
|
392
|
+
* 해제 이력까지 보려면 `status` 를 `'released'` 또는 `'all'` 로 지정합니다.
|
|
393
|
+
*/
|
|
394
|
+
async list(params = {}, options = {}) {
|
|
395
|
+
const query = stripNotGiven({
|
|
396
|
+
channel: params.channel,
|
|
397
|
+
recipient: params.recipient,
|
|
398
|
+
status: params.status,
|
|
399
|
+
page: params.page,
|
|
400
|
+
pageSize: params.pageSize
|
|
401
|
+
});
|
|
402
|
+
const path = `${this._basePath}/blocked-recipients`;
|
|
403
|
+
const raw = await this._client._get(path, {
|
|
404
|
+
castTo: PageSchema(BlockedRecipientSchema),
|
|
405
|
+
query: Object.keys(query).length ? query : void 0,
|
|
406
|
+
...options
|
|
407
|
+
});
|
|
408
|
+
const page = new Page(raw.data, raw.meta);
|
|
409
|
+
page._setClient(this._client, path, BlockedRecipientSchema, query);
|
|
410
|
+
return page;
|
|
411
|
+
}
|
|
412
|
+
/** 항목 상세를 조회합니다. 해제된 항목도 이력으로 남아 조회됩니다(`active: false`). */
|
|
413
|
+
async retrieve(blockId, options = {}) {
|
|
414
|
+
return this._client._get(`${this._basePath}/blocked-recipients/${blockId}`, {
|
|
415
|
+
castTo: BlockedRecipientSchema,
|
|
416
|
+
...options
|
|
417
|
+
});
|
|
418
|
+
}
|
|
419
|
+
/**
|
|
420
|
+
* 메모를 수정합니다.
|
|
421
|
+
*
|
|
422
|
+
* 번호와 채널은 바꿀 수 없습니다 — 바꾸면 "누가 무엇을 언제 거부했는가"라는 증빙이
|
|
423
|
+
* 뒤틀립니다. 잘못 등록했다면 해제한 뒤 올바른 번호로 새로 등록하세요.
|
|
424
|
+
*/
|
|
425
|
+
async update(blockId, params = {}, options = {}) {
|
|
426
|
+
return this._client._patch(`${this._basePath}/blocked-recipients/${blockId}`, {
|
|
427
|
+
body: { note: params.note ?? null },
|
|
428
|
+
castTo: BlockedRecipientSchema,
|
|
429
|
+
...options
|
|
430
|
+
});
|
|
431
|
+
}
|
|
432
|
+
/**
|
|
433
|
+
* 수신거부를 해제해 다시 발신할 수 있게 합니다.
|
|
434
|
+
*
|
|
435
|
+
* **항목은 삭제되지 않습니다.** `active` 가 false 가 되고 `unblockedAt` 이 기록될 뿐,
|
|
436
|
+
* 행은 이력으로 남습니다 — 언제 거부했고 언제 풀렸는지가 곧 증빙이기 때문입니다.
|
|
437
|
+
* 해제분은 `list({ status: 'released' })` 로 볼 수 있습니다.
|
|
438
|
+
*
|
|
439
|
+
* 이미 해제된 항목에 다시 호출해도 성공하며, 최초 해제 시각은 덮어쓰지 않습니다.
|
|
440
|
+
*/
|
|
441
|
+
async release(blockId, params = {}, options = {}) {
|
|
442
|
+
const body = stripNotGiven({ note: params.note });
|
|
443
|
+
return this._client._deleteWithResponse(`${this._basePath}/blocked-recipients/${blockId}`, {
|
|
444
|
+
body: Object.keys(body).length ? body : void 0,
|
|
445
|
+
castTo: BlockedRecipientSchema,
|
|
446
|
+
...options
|
|
447
|
+
});
|
|
448
|
+
}
|
|
449
|
+
};
|
|
450
|
+
var SenderNumberSchema = zod.z.object({
|
|
451
|
+
/** 발신번호 id. 삭제할 때 씁니다. */
|
|
452
|
+
id: zod.z.string(),
|
|
453
|
+
/** 발신번호(숫자만). */
|
|
454
|
+
number: zod.z.string(),
|
|
455
|
+
/** `'070'` | `'representative'`(대표번호) | `'mobile'`(이동전화) */
|
|
456
|
+
type: zod.z.string(),
|
|
457
|
+
/** `'own_provisioned'`(ClawOps 개통) | `'identity_verified'`(본인확인 이동전화) | `'usage_cert_ars'`(다른 통신사 대표번호) */
|
|
458
|
+
verificationMethod: zod.z.string(),
|
|
459
|
+
/** `'approved'` = 발송에 쓸 수 있음, `'pending'` = 승인 대기 */
|
|
460
|
+
status: zod.z.string(),
|
|
461
|
+
createdAt: zod.z.string()
|
|
462
|
+
}).passthrough();
|
|
463
|
+
var SenderNumberGraceSchema = zod.z.object({
|
|
464
|
+
number: zod.z.string(),
|
|
465
|
+
expiresAt: zod.z.string()
|
|
466
|
+
}).passthrough();
|
|
467
|
+
var SenderNumberLimitSchema = zod.z.object({
|
|
468
|
+
used: zod.z.number(),
|
|
469
|
+
limit: zod.z.number().nullable(),
|
|
470
|
+
reached: zod.z.boolean()
|
|
471
|
+
}).passthrough();
|
|
472
|
+
var SenderNumberListSchema = zod.z.object({
|
|
473
|
+
senderNumbers: zod.z.array(SenderNumberSchema),
|
|
474
|
+
grace: zod.z.array(SenderNumberGraceSchema),
|
|
475
|
+
/** 명의를 확인할 수 없으면 `null`. */
|
|
476
|
+
limit: SenderNumberLimitSchema.nullable()
|
|
477
|
+
}).passthrough();
|
|
478
|
+
var SmsSenderRegistrationSchema = zod.z.object({
|
|
479
|
+
registered: zod.z.boolean(),
|
|
480
|
+
senderNumberId: zod.z.string().optional(),
|
|
481
|
+
reason: zod.z.string().optional()
|
|
482
|
+
}).passthrough();
|
|
483
|
+
|
|
484
|
+
// src/resources/sender-numbers.ts
|
|
485
|
+
var SenderNumbers = class extends APIResource {
|
|
486
|
+
/**
|
|
487
|
+
* 등록된 발신번호(승인·승인 대기), 유예 기간인 번호, 070번호·대표번호 회선 수 한도를 함께 돌려줍니다.
|
|
488
|
+
* 발신번호 범위를 지정한 API 키로 호출하면 그 범위 안의 번호만 보입니다.
|
|
489
|
+
*/
|
|
490
|
+
async list(options = {}) {
|
|
491
|
+
return this._client._get(`${this._basePath}/sender-numbers`, {
|
|
492
|
+
castTo: SenderNumberListSchema,
|
|
493
|
+
...options
|
|
494
|
+
});
|
|
495
|
+
}
|
|
496
|
+
/**
|
|
497
|
+
* 이 계정이 ClawOps에서 개통한 070번호·대표번호를 발신번호로 등록합니다. 등록 즉시 승인됩니다.
|
|
498
|
+
*
|
|
499
|
+
* - 한 번에 한 번호씩 등록합니다. 하이픈·`+82` 표기도 받습니다.
|
|
500
|
+
* - 이미 등록된 번호면 `409 sender_number_already_registered` — 이미 발송에 쓸 수 있는 상태입니다.
|
|
501
|
+
* - 명의별 회선 수 한도를 넘으면 `422 sender_number_limit_reached`.
|
|
502
|
+
*/
|
|
503
|
+
async create(params, options = {}) {
|
|
504
|
+
return this._client._post(`${this._basePath}/sender-numbers`, {
|
|
505
|
+
body: { number: params.number },
|
|
506
|
+
castTo: SenderNumberSchema,
|
|
507
|
+
...options
|
|
508
|
+
});
|
|
509
|
+
}
|
|
510
|
+
/**
|
|
511
|
+
* 발신번호를 삭제합니다. 그 번호로는 바로 문자를 보낼 수 없고(유예도 함께 끝남) 회선 수 한도에서
|
|
512
|
+
* 빠집니다. 번호 자체는 반납되지 않습니다.
|
|
513
|
+
*
|
|
514
|
+
* API 로는 ClawOps에서 개통한 번호(`verificationMethod === 'own_provisioned'`)만 삭제할 수 있습니다 —
|
|
515
|
+
* 그 밖은 `409 sender_number_not_deletable_via_api`(콘솔에서 삭제).
|
|
516
|
+
*/
|
|
517
|
+
async delete(senderNumberId, options = {}) {
|
|
518
|
+
await this._client._delete(`${this._basePath}/sender-numbers/${senderNumberId}`, options);
|
|
519
|
+
}
|
|
520
|
+
};
|
|
521
|
+
zod.z.object({
|
|
522
|
+
/** 이 통화에서 몇 번째 시도인지(1부터). 전환 웹훅의 `TransferSequence` 와 같은 값. */
|
|
523
|
+
sequence: zod.z.number().nullable().optional(),
|
|
524
|
+
to: zod.z.string().nullable().optional(),
|
|
525
|
+
/** blind / warm / refer / refer-attended. */
|
|
526
|
+
mode: zod.z.string().nullable().optional(),
|
|
527
|
+
/** pstn / sip. 2026-07-10 이전 전환은 null. */
|
|
528
|
+
destinationType: zod.z.string().nullable().optional(),
|
|
529
|
+
/**
|
|
530
|
+
* initiated / ringing / connected / completed / failed / no-answer / busy / canceled / interrupted.
|
|
531
|
+
* enum 으로 좁히지 않는다 — 서버가 값을 넓힐 때 SDK 릴리스를 기다리지 않게(hangupCause 와 같은 이유).
|
|
532
|
+
*/
|
|
533
|
+
status: zod.z.string().nullable().optional(),
|
|
534
|
+
/** 연결→종료 초(관측값). 과금 초는 billableDuration. 연결되지 못했으면 null. */
|
|
535
|
+
duration: zod.z.number().nullable().optional(),
|
|
536
|
+
/** 과금 대상 여부. 한 통화에서 최대 한 건만 true. */
|
|
537
|
+
billable: zod.z.boolean().optional(),
|
|
538
|
+
billableDuration: zod.z.number().nullable().optional(),
|
|
539
|
+
hangupCauseQ850: zod.z.number().nullable().optional(),
|
|
540
|
+
sipResponseCode: zod.z.number().nullable().optional(),
|
|
541
|
+
/** 통신망 원본 진단 텍스트(자유 형식 — 분기 조건으로 쓰지 말 것). */
|
|
542
|
+
reasonText: zod.z.string().nullable().optional(),
|
|
543
|
+
/** 시도를 시작한 시각(ISO 8601). 2026-07-10 이전 전환은 null. */
|
|
544
|
+
startedAt: zod.z.string().nullable().optional(),
|
|
545
|
+
/**
|
|
546
|
+
* 대상이 전화를 받은 시각. 연결 전 안내 도중 끝나도 남는다.
|
|
547
|
+
*
|
|
548
|
+
* 받았는지 판정: **값이 있으면 받은 것이다** — 안내 도중 끝난 warm 전환은 status 가 `failed` 지만
|
|
549
|
+
* 받은 전환이다. 2026-10-13 이전 전환은 받았어도 null 이라, 그 구간만 status 로 판정한다.
|
|
550
|
+
*/
|
|
551
|
+
answeredAt: zod.z.string().nullable().optional(),
|
|
552
|
+
/** 발신자와 대상이 연결된 시각(안내가 있으면 안내가 끝난 뒤). 연결되지 못했으면 null. */
|
|
553
|
+
connectedAt: zod.z.string().nullable().optional(),
|
|
554
|
+
endedAt: zod.z.string().nullable().optional(),
|
|
555
|
+
/**
|
|
556
|
+
* 이 시도에 적용한 대기 한도(초). 2026-10-13 이전 전환은 null. `refer-attended` 는 이미 연결된
|
|
557
|
+
* 상담 통화로 넘겨 기다리는 단계가 없으므로 항상 null 이다.
|
|
558
|
+
*/
|
|
559
|
+
timeout: zod.z.number().nullable().optional()
|
|
560
|
+
}).passthrough();
|
|
561
|
+
var CallSchema = zod.z.object({
|
|
562
|
+
callId: zod.z.string(),
|
|
563
|
+
/**
|
|
564
|
+
* 진행 중: queued / ringing / in-progress.
|
|
565
|
+
* 종료: completed(응답 후 정상 종료) / no-answer(벨은 울렸으나 무응답) / busy(통화중) /
|
|
566
|
+
* rejected(수신 거절) / canceled(응답 전 발신 측 취소) / failed(시스템·망 오류).
|
|
567
|
+
* completed 만이 실제로 연결된 통화를 의미한다.
|
|
568
|
+
*/
|
|
569
|
+
status: zod.z.enum([
|
|
570
|
+
"queued",
|
|
571
|
+
"ringing",
|
|
572
|
+
"in-progress",
|
|
573
|
+
"completed",
|
|
574
|
+
"failed",
|
|
575
|
+
"busy",
|
|
576
|
+
"no-answer",
|
|
577
|
+
"canceled",
|
|
578
|
+
"rejected"
|
|
579
|
+
]),
|
|
580
|
+
to: zod.z.string(),
|
|
581
|
+
from: zod.z.string(),
|
|
582
|
+
direction: zod.z.enum(["outbound", "inbound"]),
|
|
583
|
+
duration: zod.z.number().nullable().optional(),
|
|
584
|
+
recordingUrl: zod.z.string().nullable().optional(),
|
|
585
|
+
/** AMD(machineDetection) 결과 — AMD 켠 발신 통화에만 값 존재. */
|
|
586
|
+
answeredBy: zod.z.enum(["human", "machine", "unknown"]).nullable().optional(),
|
|
587
|
+
/**
|
|
588
|
+
* 수신 통화에서 발신자가 번호 표시제한(`*23#` 등)을 걸고 건 통화면 true, 아니면 false.
|
|
589
|
+
* 번호는 `from` 에 그대로 있다. 발신 통화와 2026-09-29 이전의 수신 통화는 null.
|
|
590
|
+
*/
|
|
591
|
+
callerIdRestricted: zod.z.boolean().nullable().optional(),
|
|
592
|
+
/**
|
|
593
|
+
* 통화 종료 사유. status 가 왜 그렇게 끝났는지를 구분한다 — 특히 failed 는 결번·망 오류·
|
|
594
|
+
* 시스템 오류를 모두 포함하는 대분류라, 발신 리스트를 정제하려면 status 가 아니라 이 값을 본다.
|
|
595
|
+
*
|
|
596
|
+
* 재시도해도 소용없음: invalid_number(결번) / number_changed / incompatible_destination.
|
|
597
|
+
* 재시도 가치 있음: no_answer / user_busy / temporary_failure / switching_congestion /
|
|
598
|
+
* no_circuit_available / network_out_of_order / destination_out_of_order /
|
|
599
|
+
* recovery_on_timer_expire / resource_unavailable.
|
|
600
|
+
* 그 외: normal_clearing(정상 종료) / caller_canceled / call_rejected / protocol_error /
|
|
601
|
+
* unspecified / app_error·call_stuck(ClawOps 측 오류 — 재시도 권장) / unknown.
|
|
602
|
+
*
|
|
603
|
+
* enum 으로 좁히지 않는다 — 통신망이 새 cause 를 보내면 서버가 값을 넓히는데, 그때마다
|
|
604
|
+
* SDK 릴리즈를 기다려야 파싱되는 구조는 안 된다.
|
|
605
|
+
*/
|
|
606
|
+
hangupCause: zod.z.string().nullable().optional(),
|
|
607
|
+
/** 통신망 Q.850 cause code. 1·5·28=결번, 16=정상해제, 17=통화중, 19=무응답, 38=망장애. */
|
|
608
|
+
hangupCauseQ850: zod.z.number().nullable().optional(),
|
|
609
|
+
/**
|
|
610
|
+
* 종료를 유발한 SIP 응답코드(404=없는 번호, 486=통화중, 500=망 오류 등).
|
|
611
|
+
* 국내 통신망은 실제 사유를 500 으로 감싸 보내기도 하므로 hangupCause 가 더 정확하다.
|
|
612
|
+
*/
|
|
613
|
+
sipResponseCode: zod.z.number().nullable().optional(),
|
|
614
|
+
/**
|
|
615
|
+
* 종료 책임 주체. carrier(통신망) / callee(수신자) / caller(발신자) /
|
|
616
|
+
* app·system(ClawOps 측 오류 — 수신자 번호를 정제 대상에 넣지 말고 재시도할 것).
|
|
617
|
+
*/
|
|
618
|
+
hangupSource: zod.z.enum(["carrier", "callee", "caller", "app", "system"]).nullable().optional(),
|
|
619
|
+
/**
|
|
620
|
+
* 전환(담당자 연결) 요약 — 이 통화의 **대표 시도** 하나에서 나온 값이다. 대표는 **끝난 시도**
|
|
621
|
+
* (completed / failed / busy / no-answer / canceled) 중 completed 우선, 같으면 마지막 시도다.
|
|
622
|
+
*
|
|
623
|
+
* ⚠️ null 이 「전환이 없었다」를 뜻하지 않는다 — 시도가 아직 진행 중이거나 `interrupted` 로만 끝났어도
|
|
624
|
+
* null 이다. 전환 여부는 `transfers` 로 판정할 것.
|
|
625
|
+
*/
|
|
626
|
+
transferTo: zod.z.string().nullable().optional(),
|
|
627
|
+
transferStatus: zod.z.string().nullable().optional(),
|
|
628
|
+
/** 연결→종료 초(관측값, 과금 초 아님). 연결되지 못했으면 null. */
|
|
629
|
+
transferDuration: zod.z.number().nullable().optional(),
|
|
630
|
+
transferHangupCauseQ850: zod.z.number().nullable().optional(),
|
|
631
|
+
transferSipResponseCode: zod.z.number().nullable().optional(),
|
|
632
|
+
/**
|
|
633
|
+
* 통신망 원본 진단 텍스트. ⚠️ 위 대표 시도가 아니라 **마지막으로 기록된** 통신망 사유라, 여러 번
|
|
634
|
+
* 시도한 통화에서는 다른 시도의 것일 수 있다(대표 시도는 completed 인데 이 값은 실패 사유인 경우).
|
|
635
|
+
* 시도별 사유는 `transfers[].reasonText` 를 쓴다.
|
|
636
|
+
*/
|
|
637
|
+
transferReasonText: zod.z.string().nullable().optional(),
|
|
638
|
+
/**
|
|
639
|
+
* 전환 시도 전체(sequence 순). **단건 조회(`calls.get`)에만** 있고 그 밖의 응답(목록·생성·수정)에는 없다.
|
|
640
|
+
*
|
|
641
|
+
* 타입은 `TransferLeg` 지만 런타임에서는 항목이 객체인지만 본다 — 이 타입이 생기기 전에는 passthrough 로
|
|
642
|
+
* 받았으므로, 시도 하나의 값 타입이 어긋났다고 `calls.get` 전체가 검증 오류로 실패하면 회귀다.
|
|
643
|
+
*/
|
|
644
|
+
transfers: zod.z.array(zod.z.custom((v) => typeof v === "object" && v !== null && !Array.isArray(v))).optional(),
|
|
645
|
+
accountId: zod.z.string(),
|
|
646
|
+
dateCreated: zod.z.string(),
|
|
647
|
+
dateUpdated: zod.z.string().nullable().optional()
|
|
648
|
+
}).passthrough();
|
|
649
|
+
var CallControlResponseSchema = zod.z.object({
|
|
650
|
+
callId: zod.z.string(),
|
|
651
|
+
status: zod.z.string()
|
|
652
|
+
}).passthrough();
|
|
653
|
+
var TranscriptSegmentSchema = zod.z.object({
|
|
654
|
+
/**
|
|
655
|
+
* ⛔ **닫힌 enum 으로 두지 않는다.** 서버는 이미 `speaker_0` 을 보내고 있고, 세그먼트
|
|
656
|
+
* 하나가 어긋나면 `segments` 배열 때문에 **전사 응답 전체**가 실패한다.
|
|
657
|
+
*/
|
|
658
|
+
speaker: zod.z.string(),
|
|
659
|
+
start: zod.z.number(),
|
|
660
|
+
end: zod.z.number(),
|
|
661
|
+
text: zod.z.string()
|
|
662
|
+
}).passthrough();
|
|
663
|
+
var TranscriptStatusSchema = zod.z.object({
|
|
664
|
+
status: zod.z.enum(["completed", "pending", "failed", "not_requested"]),
|
|
665
|
+
callId: zod.z.string().optional(),
|
|
666
|
+
segmentCount: zod.z.number().optional(),
|
|
667
|
+
segments: zod.z.array(TranscriptSegmentSchema).optional(),
|
|
668
|
+
startedAt: zod.z.string().optional(),
|
|
669
|
+
/**
|
|
670
|
+
* ⛔ **실패 단계는 서버 코드가 만든다** — 전사 파이프라인이 `download`·`runtime`·
|
|
671
|
+
* `transcription`·`recover` 를 내보내고, 영구 실패는 예외 객체의 속성을 그대로 싣는다.
|
|
672
|
+
* 어휘가 열려 있어 스펙의 enum 조차 스냅샷일 뿐이다.
|
|
673
|
+
*
|
|
674
|
+
* ⚠️ 여기가 닫혀 있으면 **전사가 실패했을 때 그 이유를 물으면 던진다** — 고객이 가장
|
|
675
|
+
* 답을 필요로 하는 순간이다.
|
|
676
|
+
*/
|
|
677
|
+
stage: zod.z.string().nullable().optional(),
|
|
678
|
+
error: zod.z.string().nullable().optional()
|
|
679
|
+
}).passthrough();
|
|
680
|
+
var TranscriptRequestAcceptedSchema = zod.z.object({
|
|
681
|
+
status: zod.z.literal("pending"),
|
|
682
|
+
callId: zod.z.string()
|
|
683
|
+
}).passthrough();
|
|
684
|
+
var SummaryStatusSchema = zod.z.object({
|
|
685
|
+
status: zod.z.enum(["completed", "pending", "failed", "not_requested"]),
|
|
686
|
+
callId: zod.z.string().optional(),
|
|
687
|
+
resultJson: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
|
|
688
|
+
provider: zod.z.string().nullable().optional(),
|
|
689
|
+
model: zod.z.string().nullable().optional(),
|
|
690
|
+
promptVersion: zod.z.string().nullable().optional(),
|
|
691
|
+
schemaVersion: zod.z.string().nullable().optional(),
|
|
692
|
+
failedReason: zod.z.string().nullable().optional(),
|
|
693
|
+
updatedAt: zod.z.string().optional()
|
|
694
|
+
}).passthrough();
|
|
695
|
+
|
|
696
|
+
// src/resources/calls.ts
|
|
697
|
+
function callContextBody(ctx) {
|
|
698
|
+
if (!ctx) return void 0;
|
|
699
|
+
const body = { Instruction: ctx.instruction };
|
|
700
|
+
if (ctx.variables !== void 0) body.Variables = ctx.variables;
|
|
701
|
+
return body;
|
|
702
|
+
}
|
|
703
|
+
var Calls = class extends APIResource {
|
|
704
|
+
async create(params, options = {}) {
|
|
705
|
+
const body = stripNotGiven({
|
|
706
|
+
To: params.to,
|
|
707
|
+
From: params.from,
|
|
708
|
+
Url: params.url,
|
|
709
|
+
AgentId: params.agentId,
|
|
710
|
+
CallContext: callContextBody(params.callContext),
|
|
711
|
+
CallFlowId: params.callFlowId,
|
|
712
|
+
Variables: params.variables,
|
|
713
|
+
StatusCallback: params.statusCallback,
|
|
714
|
+
StatusCallbackEvent: params.statusCallbackEvent,
|
|
715
|
+
Timeout: params.timeout,
|
|
716
|
+
MachineDetection: params.machineDetection
|
|
717
|
+
});
|
|
718
|
+
return this._client._post(`${this._basePath}/calls`, {
|
|
719
|
+
body,
|
|
720
|
+
castTo: CallSchema,
|
|
721
|
+
...options
|
|
722
|
+
});
|
|
723
|
+
}
|
|
724
|
+
async list(params = {}, options = {}) {
|
|
725
|
+
const query = stripNotGiven({
|
|
726
|
+
status: params.status,
|
|
727
|
+
from: params.from,
|
|
728
|
+
to: params.to,
|
|
729
|
+
number: params.number,
|
|
730
|
+
page: params.page,
|
|
731
|
+
pageSize: params.pageSize
|
|
732
|
+
});
|
|
733
|
+
const path = `${this._basePath}/calls`;
|
|
734
|
+
const schema = PageSchema(CallSchema);
|
|
735
|
+
const raw = await this._client._get(path, {
|
|
736
|
+
castTo: schema,
|
|
737
|
+
query: Object.keys(query).length ? query : void 0,
|
|
738
|
+
...options
|
|
739
|
+
});
|
|
740
|
+
const page = new Page(raw.data, raw.meta);
|
|
741
|
+
page._setClient(this._client, path, CallSchema, query);
|
|
742
|
+
return page;
|
|
743
|
+
}
|
|
744
|
+
async get(callId, options = {}) {
|
|
745
|
+
return this._client._get(`${this._basePath}/calls/${callId}`, {
|
|
746
|
+
castTo: CallSchema,
|
|
747
|
+
...options
|
|
748
|
+
});
|
|
749
|
+
}
|
|
750
|
+
async update(callId, params = {}, options = {}) {
|
|
751
|
+
return this._client._post(`${this._basePath}/calls/${callId}`, {
|
|
752
|
+
body: { Status: params.status ?? "completed" },
|
|
753
|
+
castTo: CallControlResponseSchema,
|
|
754
|
+
...options
|
|
755
|
+
});
|
|
756
|
+
}
|
|
757
|
+
/**
|
|
758
|
+
* 통화 전사 상태 조회. 완료된 경우 segment 배열까지 한 번에 반환합니다.
|
|
759
|
+
*
|
|
760
|
+
* @throws NotFoundError (404) — 통화 없음
|
|
761
|
+
* @throws PermissionDeniedError (403) — accountId 불일치
|
|
762
|
+
*/
|
|
763
|
+
async getTranscript(callId, options = {}) {
|
|
764
|
+
return this._client._get(`${this._basePath}/calls/${callId}/transcript`, {
|
|
765
|
+
castTo: TranscriptStatusSchema,
|
|
766
|
+
...options
|
|
767
|
+
});
|
|
768
|
+
}
|
|
769
|
+
/**
|
|
770
|
+
* 특정 통화 1 건에 대해 전사를 명시 요청.
|
|
771
|
+
* 조직 설정 "통화 받아쓰기" 가 꺼져 있어도 해당 통화만 전사됩니다.
|
|
772
|
+
* 재실행 금지 — 이미 요청된 통화는 ConflictError(409) 발생.
|
|
773
|
+
* 시스템 레벨 트리거 실패(stage=trigger) 만 재시도 가능.
|
|
774
|
+
* 전사된 오디오 길이만큼 사용량 기반으로 과금됩니다.
|
|
775
|
+
*
|
|
776
|
+
* @throws BadRequestError (400) — 녹음 없음
|
|
777
|
+
* @throws NotFoundError (404) — 통화 없음
|
|
778
|
+
* @throws PermissionDeniedError (403) — accountId 불일치
|
|
779
|
+
* @throws ConflictError (409) — 이미 요청됨
|
|
780
|
+
*/
|
|
781
|
+
async requestTranscript(callId, options = {}) {
|
|
782
|
+
return this._client._post(`${this._basePath}/calls/${callId}/transcript`, {
|
|
783
|
+
castTo: TranscriptRequestAcceptedSchema,
|
|
784
|
+
...options
|
|
785
|
+
});
|
|
786
|
+
}
|
|
787
|
+
/**
|
|
788
|
+
* 통화 요약 상태 조회. transcript 가 완료된 통화에 대해 자동 생성된
|
|
789
|
+
* LLM 구조화 요약 결과를 반환합니다. completed 일 때 resultJson 채워짐.
|
|
790
|
+
*
|
|
791
|
+
* @throws NotFoundError (404) — 통화 없음
|
|
792
|
+
* @throws PermissionDeniedError (403) — accountId 불일치
|
|
793
|
+
*/
|
|
794
|
+
async getSummary(callId, options = {}) {
|
|
795
|
+
return this._client._get(`${this._basePath}/calls/${callId}/summary`, {
|
|
796
|
+
castTo: SummaryStatusSchema,
|
|
797
|
+
...options
|
|
798
|
+
});
|
|
799
|
+
}
|
|
800
|
+
};
|
|
801
|
+
var KakaoChannelSchema = zod.z.object({
|
|
802
|
+
/** ClawOps 채널 리소스 ID. 템플릿 조회와 알림톡 발송에 이 값을 쓴다. */
|
|
803
|
+
id: zod.z.string(),
|
|
804
|
+
/** 카카오 채널 검색용 ID. `@` 없는 형태로 저장된다. */
|
|
805
|
+
searchId: zod.z.string(),
|
|
806
|
+
name: zod.z.string(),
|
|
807
|
+
categoryCode: zod.z.string(),
|
|
808
|
+
/**
|
|
809
|
+
* `connected` = 연결 완료. `needs_attention` = 연결 기록은 있으나 카카오 채널 상태를
|
|
810
|
+
* 확인하지 못한 상태다 — 실제로 끊겼을 수도, 일시적인 조회 실패일 수도 있다.
|
|
811
|
+
* `channels.retrieve()` 를 다시 부르면 재확인한다.
|
|
812
|
+
*
|
|
813
|
+
* ⛔ **닫힌 enum 으로 두지 않는다.** 어휘는 서버가 소유하므로, 상태가 하나 늘면
|
|
814
|
+
* 닫힌 enum 은 조회를 통째로 실패시킨다(알림톡 `'ata'` 가 정확히 그렇게 터졌다).
|
|
815
|
+
* 열린 유니온이면 자동완성만 낡고 조회는 계속 산다.
|
|
816
|
+
*/
|
|
817
|
+
status: zod.z.string(),
|
|
818
|
+
/** 담당자 휴대전화번호(마스킹). 원문은 저장하지 않는다. */
|
|
819
|
+
managerPhoneMasked: zod.z.string().nullable().optional(),
|
|
820
|
+
connectedAt: zod.z.string(),
|
|
821
|
+
/** 카카오 채널 상태를 마지막으로 확인한 시각. null 이면 연결 이후 한 번도 확인하지 않았다. */
|
|
822
|
+
syncedAt: zod.z.string().nullable().optional(),
|
|
823
|
+
createdAt: zod.z.string(),
|
|
824
|
+
updatedAt: zod.z.string()
|
|
825
|
+
}).passthrough();
|
|
826
|
+
var KakaoTemplateSchema = zod.z.object({
|
|
827
|
+
/** ClawOps 템플릿 리소스 ID. 발송의 `kakao.templateId` 에 이 값을 쓴다. */
|
|
828
|
+
id: zod.z.string(),
|
|
829
|
+
/** ClawOps 채널 리소스 ID. 발송의 `kakao.channelId` 와 같은 값이다. */
|
|
830
|
+
channelId: zod.z.string(),
|
|
831
|
+
name: zod.z.string(),
|
|
832
|
+
/** 검수를 받은 템플릿 본문. `#{변수}` 자리는 발송 시 치환된다. */
|
|
833
|
+
content: zod.z.string(),
|
|
834
|
+
/**
|
|
835
|
+
* 카카오 검수 상태(`APPROVED`·`REJECTED` 등). **카카오 쪽 열린 집합이라 문자열이다.**
|
|
836
|
+
* 발송 가능 여부 판정은 `sendable` 이 정본이다.
|
|
837
|
+
*/
|
|
838
|
+
status: zod.z.string(),
|
|
839
|
+
/** 휴면 템플릿. `true` 면 승인 상태여도 발송할 수 없다. */
|
|
840
|
+
dormant: zod.z.boolean(),
|
|
841
|
+
/** 지금 발송에 쓸 수 있으면 true. `status === 'APPROVED' && !dormant` 다. */
|
|
842
|
+
sendable: zod.z.boolean(),
|
|
843
|
+
/** `CHANNEL`(채널 소유) 또는 `GROUP`(기본 제공). */
|
|
844
|
+
assignType: zod.z.string(),
|
|
845
|
+
messageType: zod.z.string(),
|
|
846
|
+
emphasizeType: zod.z.string(),
|
|
847
|
+
/**
|
|
848
|
+
* 발송 시 `kakao.variables` 에 모두 채워야 하는 변수 이름.
|
|
849
|
+
* 버튼 링크·강조 문구에 들어간 변수도 이 한 목록에 모인다.
|
|
850
|
+
*/
|
|
851
|
+
variables: zod.z.array(zod.z.string()),
|
|
852
|
+
createdAt: zod.z.string(),
|
|
853
|
+
updatedAt: zod.z.string()
|
|
854
|
+
}).passthrough();
|
|
855
|
+
var KakaoBrandTemplateSchema = zod.z.object({
|
|
856
|
+
/** ClawOps 템플릿 리소스 ID. 발송의 `brand.templateId` 에 이 값을 쓴다. */
|
|
857
|
+
id: zod.z.string(),
|
|
858
|
+
/** ClawOps 채널 리소스 ID. 발송의 `brand.channelId` 와 같은 값이다. */
|
|
859
|
+
channelId: zod.z.string(),
|
|
860
|
+
name: zod.z.string(),
|
|
861
|
+
chatBubbleType: zod.z.string(),
|
|
862
|
+
/**
|
|
863
|
+
* 말풍선 본문.
|
|
864
|
+
*
|
|
865
|
+
* ⚠️ **유형에 따라 `null` 이다.** 본문이 담기는 자리가 유형마다 달라 `TEXT`·`IMAGE`·
|
|
866
|
+
* `WIDE` 에만 채워진다 — 나머지는 헤더·카드·상품명이 그 자리를 대신한다.
|
|
867
|
+
*/
|
|
868
|
+
content: zod.z.string().nullable(),
|
|
869
|
+
/** 와이드리스트형의 머리말. 다른 유형에서는 `null`. */
|
|
870
|
+
header: zod.z.string().nullable(),
|
|
871
|
+
/** 발송 시 `brand.variables` 에 모두 채워야 하는 변수 이름. */
|
|
872
|
+
variables: zod.z.array(zod.z.string()),
|
|
873
|
+
createdAt: zod.z.string(),
|
|
874
|
+
updatedAt: zod.z.string()
|
|
875
|
+
}).passthrough();
|
|
876
|
+
var KakaoBrandImageSchema = zod.z.object({
|
|
877
|
+
id: zod.z.string(),
|
|
878
|
+
/** 업로드할 때 지정한 말풍선 유형. 규격이 유형마다 달라 다른 유형엔 재사용할 수 없다. */
|
|
879
|
+
bubbleType: zod.z.string(),
|
|
880
|
+
/** `'main'` | `'sub'`. 서브는 와이드리스트형에만 있다(메인 2:1, 서브 1:1). */
|
|
881
|
+
slot: zod.z.string(),
|
|
882
|
+
/** 업로드한 원본 파일 이름. */
|
|
883
|
+
name: zod.z.string().nullable(),
|
|
884
|
+
createdAt: zod.z.string()
|
|
885
|
+
}).passthrough();
|
|
886
|
+
var KakaoChannelCategorySchema = zod.z.object({
|
|
887
|
+
/** 채널 연결의 `categoryCode` 에 그대로 보내는 값. */
|
|
888
|
+
code: zod.z.string(),
|
|
889
|
+
name: zod.z.string()
|
|
890
|
+
}).passthrough();
|
|
891
|
+
var KakaoChannelCategoryListSchema = zod.z.object({
|
|
892
|
+
data: zod.z.array(KakaoChannelCategorySchema),
|
|
893
|
+
meta: zod.z.object({
|
|
894
|
+
/** 이 목록을 공급자에서 실제로 받아 온 시각. */
|
|
895
|
+
fetchedAt: zod.z.string(),
|
|
896
|
+
/** 서버 캐시에서 응답했는지. 캐시는 짧고 값이 바뀌면 자동으로 따라간다. */
|
|
897
|
+
cached: zod.z.boolean()
|
|
898
|
+
}).passthrough()
|
|
899
|
+
}).passthrough();
|
|
900
|
+
var KakaoTokenRequestSchema = zod.z.object({
|
|
901
|
+
requested: zod.z.boolean(),
|
|
902
|
+
/** 정규화된 검색용 ID. `channels.connect()` 에 이 값을 그대로 보낸다. */
|
|
903
|
+
searchId: zod.z.string(),
|
|
904
|
+
/** 인증번호가 발송된 번호(마스킹). */
|
|
905
|
+
phoneNumberMasked: zod.z.string(),
|
|
906
|
+
/** 재요청까지 기다릴 시간(초). */
|
|
907
|
+
retryAfterSeconds: zod.z.number()
|
|
908
|
+
}).passthrough();
|
|
909
|
+
|
|
910
|
+
// src/resources/kakao.ts
|
|
911
|
+
var KakaoChannels = class extends APIResource {
|
|
912
|
+
get _path() {
|
|
913
|
+
return `${this._basePath}/kakao/channels`;
|
|
914
|
+
}
|
|
915
|
+
/**
|
|
916
|
+
* 연결된 채널 목록.
|
|
917
|
+
*
|
|
918
|
+
* **카카오 쪽 상태를 확인하지 않는다** — 저장된 연결 정보를 그대로 돌려주므로 빠르다.
|
|
919
|
+
* 실제 채널 상태까지 확인하려면 `retrieve()` 를 쓴다.
|
|
920
|
+
*/
|
|
921
|
+
async list(params = {}, options = {}) {
|
|
922
|
+
const query = stripNotGiven({
|
|
923
|
+
status: params.status,
|
|
924
|
+
page: params.page,
|
|
925
|
+
pageSize: params.pageSize
|
|
926
|
+
});
|
|
927
|
+
const path = this._path;
|
|
928
|
+
const raw = await this._client._get(path, {
|
|
929
|
+
castTo: PageSchema(KakaoChannelSchema),
|
|
930
|
+
query: Object.keys(query).length ? query : void 0,
|
|
931
|
+
...options
|
|
932
|
+
});
|
|
933
|
+
const page = new Page(raw.data, raw.meta);
|
|
934
|
+
page._setClient(this._client, path, KakaoChannelSchema, query);
|
|
935
|
+
return page;
|
|
936
|
+
}
|
|
937
|
+
/**
|
|
938
|
+
* 채널 하나를 조회한다. **목록과 달리 카카오 쪽 상태를 실제로 확인하고 `status` 를 갱신한다.**
|
|
939
|
+
*
|
|
940
|
+
* `connect()` 가 타임아웃됐을 때 결과를 확정하는 경로이기도 하다 — 연결을 재호출하면 중복
|
|
941
|
+
* 등록을 시도하게 되지만 이 조회는 몇 번을 불러도 안전하다.
|
|
942
|
+
*
|
|
943
|
+
* 카카오 쪽 조회에 실패해도 `404` 가 아니다. 연결 기록은 유효하므로 `status` 가
|
|
944
|
+
* `needs_attention` 으로 온다.
|
|
945
|
+
*/
|
|
946
|
+
async retrieve(channelId, options = {}) {
|
|
947
|
+
return this._client._get(`${this._path}/${channelId}`, {
|
|
948
|
+
castTo: KakaoChannelSchema,
|
|
949
|
+
...options
|
|
950
|
+
});
|
|
951
|
+
}
|
|
952
|
+
/**
|
|
953
|
+
* 채널 권한을 증명할 인증번호를 **담당자 휴대전화로 발송**해 달라고 요청한다. 연결의 첫 단계다.
|
|
954
|
+
*
|
|
955
|
+
* 응답에 인증번호는 없다(`202`). 받은 번호는 `connect()` 의 `token` 으로 보내며, 유효 시간이
|
|
956
|
+
* 있으므로 받은 뒤 바로 진행한다. 재요청이 잦으면 `429 KAKAO_RATE_LIMITED` 이고
|
|
957
|
+
* 응답의 `retryAfterSeconds` 만큼 기다린다.
|
|
958
|
+
*/
|
|
959
|
+
async requestToken(params, options = {}) {
|
|
960
|
+
return this._client._post(`${this._path}/token`, {
|
|
961
|
+
body: { searchId: params.searchId, phoneNumber: params.phoneNumber },
|
|
962
|
+
castTo: KakaoTokenRequestSchema,
|
|
963
|
+
...options
|
|
964
|
+
});
|
|
965
|
+
}
|
|
966
|
+
/**
|
|
967
|
+
* 인증번호로 채널 연결을 완료한다. **먼저 `requestToken()` 을 불러야 한다.**
|
|
968
|
+
*
|
|
969
|
+
* **멱등이다** — 이미 이 계정에 연결된 채널이면 인증번호를 소모하지 않고 기존 연결을 돌려준다.
|
|
970
|
+
* 다른 계정에 연결된 채널은 멱등이 아니라 충돌이라 `409 KAKAO_CHANNEL_ALREADY_LINKED` 다.
|
|
971
|
+
*
|
|
972
|
+
* ⚠️ **타임아웃되면 재호출하지 말 것.** 이미 연결에 성공했을 수 있어 중복 등록을 시도하게 된다.
|
|
973
|
+
* `list()` 나 `retrieve()` 로 실제 등록 여부를 확인한 뒤 결과를 확정한다.
|
|
974
|
+
*
|
|
975
|
+
* ⚠️ **실패해도 인증번호는 소모된다**(`422 KAKAO_TOKEN_INVALID`·`KAKAO_CHANNEL_REJECTED`).
|
|
976
|
+
* 원인을 해결한 뒤 `requestToken()` 부터 다시 시작해야 한다.
|
|
977
|
+
*/
|
|
978
|
+
async connect(params, options = {}) {
|
|
979
|
+
return this._client._post(this._path, {
|
|
980
|
+
body: {
|
|
981
|
+
searchId: params.searchId,
|
|
982
|
+
phoneNumber: params.phoneNumber,
|
|
983
|
+
categoryCode: params.categoryCode,
|
|
984
|
+
token: params.token
|
|
985
|
+
},
|
|
986
|
+
castTo: KakaoChannelSchema,
|
|
987
|
+
...options
|
|
988
|
+
});
|
|
989
|
+
}
|
|
990
|
+
/**
|
|
991
|
+
* 채널 연동을 해제한다. 카카오톡 채널 자체는 지워지지 않고 ClawOps 와의 연동만 끊긴다.
|
|
992
|
+
*
|
|
993
|
+
* ⚠️ **되돌릴 수 없고, 그 채널에 등록된 알림톡 템플릿도 함께 삭제된다.** 템플릿은 카카오
|
|
994
|
+
* 검수를 다시 받아야 하므로 복구에 시간이 걸린다 — 호출 전에 사용자 확인을 받을 것.
|
|
995
|
+
*
|
|
996
|
+
* 해제 후에는 그 채널을 다시 연결할 수 있다(본인이든 다른 계정이든). `requestToken()` 부터
|
|
997
|
+
* 다시 시작하면 된다.
|
|
998
|
+
*/
|
|
999
|
+
async disconnect(channelId, options = {}) {
|
|
1000
|
+
return this._client._deleteWithResponse(`${this._path}/${channelId}`, {
|
|
1001
|
+
castTo: KakaoChannelSchema,
|
|
1002
|
+
...options
|
|
1003
|
+
});
|
|
1004
|
+
}
|
|
1005
|
+
};
|
|
1006
|
+
var KakaoTemplates = class extends APIResource {
|
|
1007
|
+
/**
|
|
1008
|
+
* 한 채널의 알림톡 템플릿 목록.
|
|
1009
|
+
*
|
|
1010
|
+
* 응답의 `data[].id` 를 발송의 `kakao.templateId` 로, `data[].channelId` 를
|
|
1011
|
+
* `kakao.channelId` 로 쓴다. **`sendable: true` 인 템플릿만 발송할 수 있고**,
|
|
1012
|
+
* `variables` 의 모든 항목을 발송 요청의 `kakao.variables` 에 채워야 한다.
|
|
1013
|
+
*/
|
|
1014
|
+
async list(params, options = {}) {
|
|
1015
|
+
const query = stripNotGiven({
|
|
1016
|
+
channelId: params.channelId,
|
|
1017
|
+
page: params.page,
|
|
1018
|
+
pageSize: params.pageSize
|
|
1019
|
+
});
|
|
1020
|
+
const path = `${this._basePath}/kakao/templates`;
|
|
1021
|
+
const raw = await this._client._get(path, {
|
|
1022
|
+
castTo: PageSchema(KakaoTemplateSchema),
|
|
1023
|
+
query: Object.keys(query).length ? query : void 0,
|
|
1024
|
+
...options
|
|
1025
|
+
});
|
|
1026
|
+
const page = new Page(raw.data, raw.meta);
|
|
1027
|
+
page._setClient(this._client, path, KakaoTemplateSchema, query);
|
|
1028
|
+
return page;
|
|
1029
|
+
}
|
|
1030
|
+
};
|
|
1031
|
+
var KakaoBrandTemplates = class extends APIResource {
|
|
1032
|
+
/**
|
|
1033
|
+
* 한 채널의 브랜드 메시지 템플릿 목록.
|
|
1034
|
+
*
|
|
1035
|
+
* 응답의 `data[].id` 를 발송의 `brand.templateId` 로, `data[].channelId` 를
|
|
1036
|
+
* `brand.channelId` 로 쓴다. `variables` 의 모든 항목을 `brand.variables` 에 채워야 한다.
|
|
1037
|
+
*
|
|
1038
|
+
* ⭐ **알림톡과 달리 검수가 없어** `sendable` 같은 칸이 없다 — 목록에 있으면 곧 보낼 수 있다.
|
|
1039
|
+
*/
|
|
1040
|
+
async list(params, options = {}) {
|
|
1041
|
+
const query = stripNotGiven({
|
|
1042
|
+
channelId: params.channelId,
|
|
1043
|
+
page: params.page,
|
|
1044
|
+
pageSize: params.pageSize
|
|
1045
|
+
});
|
|
1046
|
+
const path = `${this._basePath}/kakao/brand-templates`;
|
|
1047
|
+
const raw = await this._client._get(path, {
|
|
1048
|
+
castTo: PageSchema(KakaoBrandTemplateSchema),
|
|
1049
|
+
query: Object.keys(query).length ? query : void 0,
|
|
1050
|
+
...options
|
|
1051
|
+
});
|
|
1052
|
+
const page = new Page(raw.data, raw.meta);
|
|
1053
|
+
page._setClient(this._client, path, KakaoBrandTemplateSchema, query);
|
|
1054
|
+
return page;
|
|
1055
|
+
}
|
|
1056
|
+
};
|
|
1057
|
+
var KakaoBrandImages = class extends APIResource {
|
|
1058
|
+
get _path() {
|
|
1059
|
+
return `${this._basePath}/kakao/brand-images`;
|
|
1060
|
+
}
|
|
1061
|
+
/**
|
|
1062
|
+
* 이미지를 올리고 발송에 쓸 `id` 를 받는다.
|
|
1063
|
+
*
|
|
1064
|
+
* ```ts
|
|
1065
|
+
* const image = await client.kakao.brandImages.upload({
|
|
1066
|
+
* file: readFileSync('banner.png'),
|
|
1067
|
+
* filename: 'banner.png',
|
|
1068
|
+
* bubbleType: 'WIDE',
|
|
1069
|
+
* });
|
|
1070
|
+
* await client.messages.create({
|
|
1071
|
+
* to: '01012345678',
|
|
1072
|
+
* from: '07012345678',
|
|
1073
|
+
* brand: {
|
|
1074
|
+
* channelId,
|
|
1075
|
+
* free: { chatBubbleType: 'WIDE', content: '신메뉴가 나왔어요.', imageId: image.id },
|
|
1076
|
+
* },
|
|
1077
|
+
* });
|
|
1078
|
+
* ```
|
|
1079
|
+
*
|
|
1080
|
+
* ⚠️ `TEXT` 는 이미지 자리가 없어 `400` 이다. 자동완성에 뜨지만 쓸 수 없다.
|
|
1081
|
+
*
|
|
1082
|
+
* ⚠️ **상한은 5MB 다.** 넘으면 `400`, 10MB 를 넘으면 업로드 검증기가 먼저 끊어 `413` 이고
|
|
1083
|
+
* **`code` 가 없다** — 즉 "너무 크다" 가 두 모양으로 온다.
|
|
1084
|
+
*
|
|
1085
|
+
* @param params.filename 원본 파일 이름. 목록에서 사람이 알아볼 유일한 단서다.
|
|
1086
|
+
* @param params.slot 와이드리스트형에서 작은 항목에 쓸 이미지면 `'sub'`. 기본은 `'main'`.
|
|
1087
|
+
*/
|
|
1088
|
+
async upload(params, options = {}) {
|
|
1089
|
+
const form = new FormData();
|
|
1090
|
+
const blob = params.file instanceof Blob ? params.file : new Blob([params.file]);
|
|
1091
|
+
form.append("image", blob, params.filename);
|
|
1092
|
+
form.append("bubbleType", params.bubbleType);
|
|
1093
|
+
if (params.slot) form.append("slot", params.slot);
|
|
1094
|
+
return this._client._post(this._path, {
|
|
1095
|
+
body: form,
|
|
1096
|
+
castTo: zod.z.object({ id: zod.z.string() }).passthrough(),
|
|
1097
|
+
...options
|
|
1098
|
+
});
|
|
1099
|
+
}
|
|
1100
|
+
/** 올려 둔 이미지 목록. **`id` 를 잃었을 때 되찾는 경로다.** */
|
|
1101
|
+
async list(params = {}, options = {}) {
|
|
1102
|
+
const query = stripNotGiven({ page: params.page, pageSize: params.pageSize });
|
|
1103
|
+
const path = this._path;
|
|
1104
|
+
const raw = await this._client._get(path, {
|
|
1105
|
+
castTo: PageSchema(KakaoBrandImageSchema),
|
|
1106
|
+
query: Object.keys(query).length ? query : void 0,
|
|
1107
|
+
...options
|
|
1108
|
+
});
|
|
1109
|
+
const page = new Page(raw.data, raw.meta);
|
|
1110
|
+
page._setClient(this._client, path, KakaoBrandImageSchema, query);
|
|
1111
|
+
return page;
|
|
1112
|
+
}
|
|
1113
|
+
};
|
|
1114
|
+
var Kakao = class extends APIResource {
|
|
1115
|
+
get channels() {
|
|
1116
|
+
return new KakaoChannels(this._client, this._accountId);
|
|
1117
|
+
}
|
|
1118
|
+
get templates() {
|
|
1119
|
+
return new KakaoTemplates(this._client, this._accountId);
|
|
1120
|
+
}
|
|
1121
|
+
/** 브랜드 메시지 템플릿. 알림톡 템플릿(`templates`)과 **다른 표**다. */
|
|
1122
|
+
get brandTemplates() {
|
|
1123
|
+
return new KakaoBrandTemplates(this._client, this._accountId);
|
|
1124
|
+
}
|
|
1125
|
+
/** 자유형 말풍선에 실을 이미지. 템플릿형은 이미지가 템플릿에 들어 있어 필요 없다. */
|
|
1126
|
+
get brandImages() {
|
|
1127
|
+
return new KakaoBrandImages(this._client, this._accountId);
|
|
1128
|
+
}
|
|
1129
|
+
/**
|
|
1130
|
+
* 채널 연결 시 지정할 업종 카테고리 목록.
|
|
1131
|
+
*
|
|
1132
|
+
* **값을 코드에 하드코딩하지 말 것** — 카카오/공급자 쪽에서 늘거나 바뀌는 열린 집합이고
|
|
1133
|
+
* 이 응답이 그때그때의 정본이다. 응답의 `code` 를 `channels.connect()` 의 `categoryCode`
|
|
1134
|
+
* 로 그대로 보낸다.
|
|
1135
|
+
*
|
|
1136
|
+
* 페이지네이션이 없어 `Page` 가 아니라 `{ data, meta }` 를 그대로 돌려준다.
|
|
1137
|
+
*/
|
|
1138
|
+
async channelCategories(options = {}) {
|
|
1139
|
+
return this._client._get(`${this._basePath}/kakao/channel-categories`, {
|
|
1140
|
+
castTo: KakaoChannelCategoryListSchema,
|
|
1141
|
+
...options
|
|
1142
|
+
});
|
|
1143
|
+
}
|
|
1144
|
+
};
|
|
1145
|
+
var MessageSchema = zod.z.object({
|
|
1146
|
+
messageId: zod.z.string(),
|
|
1147
|
+
status: zod.z.string(),
|
|
1148
|
+
/**
|
|
1149
|
+
* `'ata'`(알림톡)·`'bms'`(브랜드 메시지)는 카카오로 나간다. `body` 에는 템플릿에 변수를
|
|
1150
|
+
* 치환한 결과가 담기고, 버튼·아이템 리스트·강조 문구는 템플릿에 담긴 대로 발송되어
|
|
1151
|
+
* 이 값에는 담기지 않는다.
|
|
1152
|
+
*
|
|
1153
|
+
* ⛔ **닫힌 enum 으로 두지 않는다.** 어휘는 서버가 소유하므로, 유형이 하나 늘면 닫힌
|
|
1154
|
+
* enum 은 **목록을 통째로** 실패시킨다(`list()` 는 페이지를 한 번에 파싱한다). 실제로
|
|
1155
|
+
* 두 번 그렇게 터졌다 — `'ata'` 가 나왔을 때, 그리고 `'bms'` 가 나왔을 때.
|
|
1156
|
+
*/
|
|
1157
|
+
type: zod.z.string(),
|
|
1158
|
+
to: zod.z.string(),
|
|
1159
|
+
from: zod.z.string(),
|
|
1160
|
+
body: zod.z.string().nullable().optional(),
|
|
1161
|
+
subject: zod.z.string().nullable().optional(),
|
|
1162
|
+
numMedia: zod.z.number(),
|
|
1163
|
+
mediaUrl: zod.z.array(zod.z.string()),
|
|
1164
|
+
direction: zod.z.enum(["outbound", "inbound"]),
|
|
1165
|
+
accountId: zod.z.string(),
|
|
1166
|
+
dateCreated: zod.z.string(),
|
|
1167
|
+
dateUpdated: zod.z.string().nullable().optional()
|
|
1168
|
+
}).passthrough();
|
|
1169
|
+
|
|
1170
|
+
// src/resources/messages.ts
|
|
1171
|
+
var sendBlock = (p) => p && stripNotGiven({
|
|
1172
|
+
ChannelId: p.channelId,
|
|
1173
|
+
TemplateId: p.templateId,
|
|
1174
|
+
Variables: p.variables,
|
|
1175
|
+
Free: p.free
|
|
1176
|
+
});
|
|
1177
|
+
var Messages = class extends APIResource {
|
|
1178
|
+
/**
|
|
1179
|
+
* 문자(SMS/LMS/MMS) 또는 카카오 알림톡·브랜드 메시지를 발송합니다.
|
|
1180
|
+
*
|
|
1181
|
+
* 셋은 배타적입니다 — `kakao` 를 실으면 알림톡, `brand` 를 실으면 브랜드 메시지이고,
|
|
1182
|
+
* 이때 `body`·`subject`·`mediaUrl` 은 실을 수 없습니다(본문은 템플릿이 정합니다).
|
|
1183
|
+
*
|
|
1184
|
+
* ```ts
|
|
1185
|
+
* // 문자
|
|
1186
|
+
* await client.messages.create({ to: '010…', from: '070…', body: '안녕하세요' });
|
|
1187
|
+
*
|
|
1188
|
+
* // 알림톡 — 실패하면 fallback 문구가 문자로 대신 나갑니다(별도 1건으로 과금)
|
|
1189
|
+
* await client.messages.create({
|
|
1190
|
+
* to: '010…',
|
|
1191
|
+
* from: '070…',
|
|
1192
|
+
* kakao: { channelId, templateId, variables: { 고객명: '홍길동' } },
|
|
1193
|
+
* fallback: { body: '주문이 접수되었습니다.' },
|
|
1194
|
+
* });
|
|
1195
|
+
*
|
|
1196
|
+
* // 브랜드 메시지 — 채널을 추가한 친구에게 나가는 광고성 메시지
|
|
1197
|
+
* // ⚠️ 야간 제한과 대체발송 없음 — 제약은 `BrandMessageCreateParams` 참고.
|
|
1198
|
+
* await client.messages.create({
|
|
1199
|
+
* to: '010…',
|
|
1200
|
+
* from: '070…',
|
|
1201
|
+
* brand: { channelId, templateId, variables: { 고객명: '홍길동' } },
|
|
1202
|
+
* });
|
|
1203
|
+
* ```
|
|
1204
|
+
*/
|
|
1205
|
+
async create(params, options = {}) {
|
|
1206
|
+
const body = stripNotGiven({
|
|
1207
|
+
To: params.to,
|
|
1208
|
+
From: params.from,
|
|
1209
|
+
Body: params.body,
|
|
1210
|
+
Type: params.type,
|
|
1211
|
+
Subject: params.subject,
|
|
1212
|
+
MediaUrl: params.mediaUrl,
|
|
1213
|
+
IdempotencyKey: params.idempotencyKey,
|
|
1214
|
+
// 중첩 객체는 손으로 조립한다 — stripNotGiven 은 한 겹만 훑는다.
|
|
1215
|
+
Kakao: sendBlock(params.kakao),
|
|
1216
|
+
Brand: sendBlock(params.brand),
|
|
1217
|
+
Fallback: params.fallback && stripNotGiven({
|
|
1218
|
+
Type: params.fallback.type,
|
|
1219
|
+
Subject: params.fallback.subject,
|
|
1220
|
+
Body: params.fallback.body,
|
|
1221
|
+
Disabled: params.fallback.disabled
|
|
1222
|
+
})
|
|
1223
|
+
});
|
|
1224
|
+
return this._client._post(`${this._basePath}/messages`, {
|
|
1225
|
+
body,
|
|
1226
|
+
castTo: MessageSchema,
|
|
1227
|
+
...options
|
|
1228
|
+
});
|
|
1229
|
+
}
|
|
1230
|
+
async list(params = {}, options = {}) {
|
|
1231
|
+
const query = stripNotGiven({
|
|
1232
|
+
type: params.type,
|
|
1233
|
+
status: params.status,
|
|
1234
|
+
number: params.number,
|
|
1235
|
+
page: params.page,
|
|
1236
|
+
pageSize: params.pageSize
|
|
1237
|
+
});
|
|
1238
|
+
const path = `${this._basePath}/messages`;
|
|
1239
|
+
const schema = PageSchema(MessageSchema);
|
|
1240
|
+
const raw = await this._client._get(path, {
|
|
1241
|
+
castTo: schema,
|
|
1242
|
+
query: Object.keys(query).length ? query : void 0,
|
|
1243
|
+
...options
|
|
1244
|
+
});
|
|
1245
|
+
const page = new Page(raw.data, raw.meta);
|
|
1246
|
+
page._setClient(this._client, path, MessageSchema, query);
|
|
1247
|
+
return page;
|
|
1248
|
+
}
|
|
1249
|
+
async get(messageId, options = {}) {
|
|
1250
|
+
return this._client._get(`${this._basePath}/messages/${messageId}`, {
|
|
1251
|
+
castTo: MessageSchema,
|
|
1252
|
+
...options
|
|
1253
|
+
});
|
|
1254
|
+
}
|
|
1255
|
+
};
|
|
1256
|
+
var PhoneNumberSchema = zod.z.object({
|
|
1257
|
+
number: zod.z.string(),
|
|
1258
|
+
numberType: zod.z.string().nullable().optional(),
|
|
1259
|
+
source: zod.z.string().nullable().optional(),
|
|
1260
|
+
// routingType 은 enum 으로 좁히지 않는다. 좁히면 서버가 라우팅 종류를 늘렸을 때 그 번호가
|
|
1261
|
+
// 섞인 목록 조회가 통째로 실패한다(0.28.0 까지의 실제 결함: 'agent' 로 라우팅된 번호
|
|
1262
|
+
// 하나가 numbers.list() 전체를 깨뜨렸다).
|
|
1263
|
+
routingType: zod.z.string().nullable().optional(),
|
|
1264
|
+
agentId: zod.z.string().nullable().optional(),
|
|
1265
|
+
callFlowId: zod.z.string().nullable().optional(),
|
|
1266
|
+
forwardTo: zod.z.string().nullable().optional(),
|
|
1267
|
+
sipEndpointId: zod.z.string().nullable().optional(),
|
|
1268
|
+
sipCredentialId: zod.z.string().nullable().optional(),
|
|
1269
|
+
webhookUrl: zod.z.string().nullable().optional(),
|
|
1270
|
+
webhookMethod: zod.z.string().nullable().optional(),
|
|
1271
|
+
webhookHeaders: zod.z.record(zod.z.string()).nullable().optional(),
|
|
1272
|
+
callContextUrl: zod.z.string().nullable().optional(),
|
|
1273
|
+
statusCallback: zod.z.string().nullable().optional(),
|
|
1274
|
+
statusCallbackEvents: zod.z.string().nullable().optional(),
|
|
1275
|
+
dictionaryId: zod.z.string().nullable().optional(),
|
|
1276
|
+
createdAt: zod.z.string().nullable().optional()
|
|
1277
|
+
}).passthrough();
|
|
1278
|
+
var ProvisionedPhoneNumberSchema = PhoneNumberSchema.extend({
|
|
1279
|
+
smsSender: SmsSenderRegistrationSchema.optional()
|
|
1280
|
+
});
|
|
1281
|
+
|
|
1282
|
+
// src/resources/numbers.ts
|
|
1283
|
+
var Numbers = class extends APIResource {
|
|
1284
|
+
/**
|
|
1285
|
+
* 번호를 발급합니다. 번호 풀에서 자동으로 배정되며 어떤 번호가 나올지는 지정할 수 없습니다.
|
|
1286
|
+
*
|
|
1287
|
+
* 발급 직후 번호는 `routingType: "webhook"` 이고 `webhookUrl` 이 비어 있어, 그대로 두면
|
|
1288
|
+
* 걸려온 전화가 거절됩니다. 이어서 `update()` 로 착신 라우팅을 지정하세요.
|
|
1289
|
+
*
|
|
1290
|
+
* 회선 수 한도 안이면 문자 발신번호로도 자동 등록되며, 결과는 `smsSender` 에 실립니다.
|
|
1291
|
+
* `smsSender.registered` 가 `false` 여도 발급은 성공입니다 — 그 번호로 문자를 보내려면
|
|
1292
|
+
* `reason` 을 해결한 뒤 `senderNumbers.create()` 로 등록하세요.
|
|
1293
|
+
*/
|
|
1294
|
+
async create(params = {}, options = {}) {
|
|
1295
|
+
const body = stripNotGiven({
|
|
1296
|
+
webhookUrl: params.webhookUrl,
|
|
1297
|
+
webhookMethod: params.webhookMethod,
|
|
1298
|
+
webhookHeaders: params.webhookHeaders,
|
|
1299
|
+
statusCallback: params.statusCallback,
|
|
1300
|
+
statusCallbackEvents: params.statusCallbackEvents
|
|
1301
|
+
});
|
|
1302
|
+
return this._client._post(`${this._basePath}/numbers`, {
|
|
1303
|
+
body: Object.keys(body).length ? body : void 0,
|
|
1304
|
+
castTo: ProvisionedPhoneNumberSchema,
|
|
1305
|
+
...options
|
|
1306
|
+
});
|
|
1307
|
+
}
|
|
1308
|
+
/**
|
|
1309
|
+
* 등록된 번호 목록을 조회합니다. 페이지네이션과 필터가 없으며 보유한 번호가 한 번에 전부
|
|
1310
|
+
* 반환됩니다.
|
|
1311
|
+
*/
|
|
1312
|
+
async list(options = {}) {
|
|
1313
|
+
const schema = zod.z.object({ data: zod.z.array(PhoneNumberSchema) }).passthrough();
|
|
1314
|
+
const result = await this._client._get(`${this._basePath}/numbers`, {
|
|
1315
|
+
castTo: schema,
|
|
1316
|
+
...options
|
|
1317
|
+
});
|
|
1318
|
+
return result.data;
|
|
1319
|
+
}
|
|
1320
|
+
/**
|
|
1321
|
+
* 번호 설정을 수정합니다. 착신 라우팅(webhook/agent/callflow/forward/sip/softphone)과
|
|
1322
|
+
* webhook, 상태 통지, 받아쓰기 사전을 변경할 수 있습니다. 보낸 필드만 반영되고 생략한
|
|
1323
|
+
* 필드는 유지됩니다.
|
|
1324
|
+
*
|
|
1325
|
+
* 라우팅을 바꾸면 다른 라우팅 필드는 서버에서 자동으로 비워집니다. `agent` 에서
|
|
1326
|
+
* `webhook` 으로 되돌리면 `agentId` 가 null 이 되므로, 다시 `agent` 로 돌아갈 때
|
|
1327
|
+
* `agentId` 를 새로 지정해야 합니다.
|
|
1328
|
+
*/
|
|
1329
|
+
async update(number, params = {}, options = {}) {
|
|
1330
|
+
const body = stripNotGiven({
|
|
1331
|
+
routingType: params.routingType,
|
|
1332
|
+
agentId: params.agentId,
|
|
1333
|
+
callFlowId: params.callFlowId,
|
|
1334
|
+
forwardTo: params.forwardTo,
|
|
1335
|
+
sipEndpointId: params.sipEndpointId,
|
|
1336
|
+
sipCredentialId: params.sipCredentialId,
|
|
1337
|
+
webhookUrl: params.webhookUrl,
|
|
1338
|
+
webhookMethod: params.webhookMethod,
|
|
1339
|
+
webhookHeaders: params.webhookHeaders,
|
|
1340
|
+
callContextUrl: params.callContextUrl,
|
|
1341
|
+
statusCallback: params.statusCallback,
|
|
1342
|
+
statusCallbackEvents: params.statusCallbackEvents,
|
|
1343
|
+
dictionaryId: params.dictionaryId
|
|
1344
|
+
});
|
|
1345
|
+
return this._client._put(`${this._basePath}/numbers/${number}`, {
|
|
1346
|
+
body,
|
|
1347
|
+
castTo: PhoneNumberSchema,
|
|
1348
|
+
...options
|
|
1349
|
+
});
|
|
1350
|
+
}
|
|
1351
|
+
/**
|
|
1352
|
+
* 번호를 반납합니다. 번호는 풀로 복귀하며 되돌릴 수 없습니다. 같은 번호를 다시
|
|
1353
|
+
* 발급받는다는 보장이 없습니다.
|
|
1354
|
+
*/
|
|
1355
|
+
async delete(number, options = {}) {
|
|
1356
|
+
await this._client._delete(`${this._basePath}/numbers/${number}`, options);
|
|
1357
|
+
}
|
|
1358
|
+
};
|
|
1359
|
+
|
|
1360
|
+
// src/resources/recordings.ts
|
|
1361
|
+
function parseFilename(disposition) {
|
|
1362
|
+
if (!disposition) return null;
|
|
1363
|
+
const star = disposition.match(/filename\*=(?:[\w-]+'[^']*')?([^;]+)/i);
|
|
1364
|
+
if (star) {
|
|
1365
|
+
try {
|
|
1366
|
+
return decodeURIComponent(star[1].trim());
|
|
1367
|
+
} catch {
|
|
1368
|
+
}
|
|
1369
|
+
}
|
|
1370
|
+
const quoted = disposition.match(/filename="([^"]+)"/i);
|
|
1371
|
+
if (quoted) return quoted[1].trim();
|
|
1372
|
+
const bare = disposition.match(/filename=([^;]+)/i);
|
|
1373
|
+
return bare ? bare[1].trim() : null;
|
|
1374
|
+
}
|
|
1375
|
+
var Recordings = class extends APIResource {
|
|
1376
|
+
/**
|
|
1377
|
+
* 통화 녹음(WAV)을 다운로드합니다.
|
|
1378
|
+
*
|
|
1379
|
+
* 콘솔과 동일한 서버측 MixMonitor 원본 (PCM 16bit mono 8kHz).
|
|
1380
|
+
*
|
|
1381
|
+
* @throws NotFoundError (404) — 통화가 없거나 녹음이 없음(`recordingUrl: null`).
|
|
1382
|
+
* @throws PermissionDeniedError (403) — accountId 불일치.
|
|
1383
|
+
*/
|
|
1384
|
+
async download(callId, options = {}) {
|
|
1385
|
+
const response = await this._client._getRaw(
|
|
1386
|
+
`${this._basePath}/recordings/${callId}`,
|
|
1387
|
+
options
|
|
1388
|
+
);
|
|
1389
|
+
const data = await response.arrayBuffer();
|
|
1390
|
+
return {
|
|
1391
|
+
data,
|
|
1392
|
+
contentType: response.headers.get("content-type") ?? "audio/wav",
|
|
1393
|
+
filename: parseFilename(response.headers.get("content-disposition"))
|
|
1394
|
+
};
|
|
1395
|
+
}
|
|
1396
|
+
/**
|
|
1397
|
+
* 통화 녹음을 삭제합니다 (포인터 제거, 멱등 — 이미 없어도 성공).
|
|
1398
|
+
*
|
|
1399
|
+
* @throws NotFoundError (404) — 통화가 없음.
|
|
1400
|
+
* @throws PermissionDeniedError (403) — accountId 불일치.
|
|
1401
|
+
*/
|
|
1402
|
+
async delete(callId, options = {}) {
|
|
1403
|
+
await this._client._delete(`${this._basePath}/recordings/${callId}`, options);
|
|
1404
|
+
}
|
|
1405
|
+
};
|
|
1406
|
+
var SipCredentialSchema = zod.z.object({
|
|
1407
|
+
id: zod.z.string(),
|
|
1408
|
+
accountId: zod.z.string().nullable().optional(),
|
|
1409
|
+
name: zod.z.string().nullable().optional(),
|
|
1410
|
+
username: zod.z.string().nullable().optional(),
|
|
1411
|
+
realm: zod.z.string().nullable().optional(),
|
|
1412
|
+
enabled: zod.z.boolean().nullable().optional(),
|
|
1413
|
+
status: zod.z.enum(["active", "disabled", "deleted"]).nullable().optional(),
|
|
1414
|
+
ipAclId: zod.z.string().nullable().optional(),
|
|
1415
|
+
allowedNumbers: zod.z.array(zod.z.string()).nullable().optional(),
|
|
1416
|
+
lastUsedAt: zod.z.string().nullable().optional(),
|
|
1417
|
+
dateCreated: zod.z.string().nullable().optional(),
|
|
1418
|
+
dateUpdated: zod.z.string().nullable().optional()
|
|
1419
|
+
}).passthrough();
|
|
1420
|
+
var SipEndpointSchema = zod.z.object({
|
|
1421
|
+
id: zod.z.string(),
|
|
1422
|
+
accountId: zod.z.string().nullable().optional(),
|
|
1423
|
+
name: zod.z.string().nullable().optional(),
|
|
1424
|
+
maxConcurrent: zod.z.number().nullable().optional(),
|
|
1425
|
+
status: zod.z.enum(["active", "disabled"]).nullable().optional(),
|
|
1426
|
+
routes: zod.z.array(zod.z.unknown()).nullable().optional(),
|
|
1427
|
+
dateCreated: zod.z.string().nullable().optional(),
|
|
1428
|
+
dateUpdated: zod.z.string().nullable().optional()
|
|
1429
|
+
}).passthrough();
|
|
1430
|
+
|
|
1431
|
+
// src/resources/sip-credentials.ts
|
|
1432
|
+
var SipCredentials = class extends APIResource {
|
|
1433
|
+
async list(params = {}, options = {}) {
|
|
1434
|
+
const query = stripNotGiven({
|
|
1435
|
+
status: params.status,
|
|
1436
|
+
page: params.page,
|
|
1437
|
+
pageSize: params.pageSize
|
|
1438
|
+
});
|
|
1439
|
+
const schema = zod.z.object({ data: zod.z.array(SipCredentialSchema) }).passthrough();
|
|
1440
|
+
const result = await this._client._get(`${this._basePath}/sip-credentials`, {
|
|
1441
|
+
castTo: schema,
|
|
1442
|
+
...options,
|
|
1443
|
+
extraQuery: { ...query, ...options.extraQuery }
|
|
1444
|
+
});
|
|
1445
|
+
return result.data;
|
|
1446
|
+
}
|
|
1447
|
+
async get(credentialId, options = {}) {
|
|
1448
|
+
return this._client._get(`${this._basePath}/sip-credentials/${credentialId}`, {
|
|
1449
|
+
castTo: SipCredentialSchema,
|
|
1450
|
+
...options
|
|
1451
|
+
});
|
|
1452
|
+
}
|
|
1453
|
+
};
|
|
1454
|
+
var SipEndpoints = class extends APIResource {
|
|
1455
|
+
async list(params = {}, options = {}) {
|
|
1456
|
+
const query = stripNotGiven({
|
|
1457
|
+
status: params.status,
|
|
1458
|
+
page: params.page,
|
|
1459
|
+
pageSize: params.pageSize
|
|
1460
|
+
});
|
|
1461
|
+
const schema = zod.z.object({ data: zod.z.array(SipEndpointSchema) }).passthrough();
|
|
1462
|
+
const result = await this._client._get(`${this._basePath}/sip-endpoints`, {
|
|
1463
|
+
castTo: schema,
|
|
1464
|
+
...options,
|
|
1465
|
+
extraQuery: { ...query, ...options.extraQuery }
|
|
1466
|
+
});
|
|
1467
|
+
return result.data;
|
|
1468
|
+
}
|
|
1469
|
+
async get(endpointId, options = {}) {
|
|
1470
|
+
return this._client._get(`${this._basePath}/sip-endpoints/${endpointId}`, {
|
|
1471
|
+
castTo: SipEndpointSchema,
|
|
1472
|
+
...options
|
|
1473
|
+
});
|
|
1474
|
+
}
|
|
1475
|
+
};
|
|
1476
|
+
var WebhookLogSchema = zod.z.object({
|
|
1477
|
+
id: zod.z.string(),
|
|
1478
|
+
webhookId: zod.z.string(),
|
|
1479
|
+
event: zod.z.string(),
|
|
1480
|
+
requestUrl: zod.z.string(),
|
|
1481
|
+
requestPayload: zod.z.record(zod.z.unknown()),
|
|
1482
|
+
responseStatus: zod.z.number().nullable().optional(),
|
|
1483
|
+
responseBody: zod.z.string().nullable().optional(),
|
|
1484
|
+
responseTimeMs: zod.z.number().nullable().optional(),
|
|
1485
|
+
status: zod.z.enum(["pending", "delivered", "failed"]),
|
|
1486
|
+
attempt: zod.z.number(),
|
|
1487
|
+
maxAttempts: zod.z.number(),
|
|
1488
|
+
createdAt: zod.z.string(),
|
|
1489
|
+
completedAt: zod.z.string().nullable().optional()
|
|
1490
|
+
}).passthrough();
|
|
1491
|
+
|
|
1492
|
+
// src/resources/webhook-logs.ts
|
|
1493
|
+
var WebhookLogs = class extends APIResource {
|
|
1494
|
+
async list(webhookId, params = {}, options = {}) {
|
|
1495
|
+
const query = stripNotGiven({ page: params.page, pageSize: params.pageSize });
|
|
1496
|
+
const path = `${this._basePath}/webhooks/${webhookId}/logs`;
|
|
1497
|
+
const schema = PageSchema(WebhookLogSchema);
|
|
1498
|
+
const raw = await this._client._get(path, {
|
|
1499
|
+
castTo: schema,
|
|
1500
|
+
query: Object.keys(query).length ? query : void 0,
|
|
1501
|
+
...options
|
|
1502
|
+
});
|
|
1503
|
+
const page = new Page(raw.data, raw.meta);
|
|
1504
|
+
page._setClient(this._client, path, WebhookLogSchema, query);
|
|
1505
|
+
return page;
|
|
1506
|
+
}
|
|
1507
|
+
};
|
|
1508
|
+
|
|
1509
|
+
// src/resources/accounts.ts
|
|
1510
|
+
var AccountContext = class {
|
|
1511
|
+
_client;
|
|
1512
|
+
_accountId;
|
|
1513
|
+
constructor(client, accountId) {
|
|
1514
|
+
this._client = client;
|
|
1515
|
+
this._accountId = accountId;
|
|
1516
|
+
}
|
|
1517
|
+
get calls() {
|
|
1518
|
+
return new Calls(this._client, this._accountId);
|
|
1519
|
+
}
|
|
1520
|
+
get messages() {
|
|
1521
|
+
return new Messages(this._client, this._accountId);
|
|
1522
|
+
}
|
|
1523
|
+
get numbers() {
|
|
1524
|
+
return new Numbers(this._client, this._accountId);
|
|
1525
|
+
}
|
|
1526
|
+
get recordings() {
|
|
1527
|
+
return new Recordings(this._client, this._accountId);
|
|
1528
|
+
}
|
|
1529
|
+
get webhookLogs() {
|
|
1530
|
+
return new WebhookLogs(this._client, this._accountId);
|
|
1531
|
+
}
|
|
1532
|
+
get assignmentLinks() {
|
|
1533
|
+
return new AssignmentLinks(this._client, this._accountId);
|
|
1534
|
+
}
|
|
1535
|
+
get blockedRecipients() {
|
|
1536
|
+
return new BlockedRecipients(this._client, this._accountId);
|
|
1537
|
+
}
|
|
1538
|
+
get senderNumbers() {
|
|
1539
|
+
return new SenderNumbers(this._client, this._accountId);
|
|
1540
|
+
}
|
|
1541
|
+
get kakao() {
|
|
1542
|
+
return new Kakao(this._client, this._accountId);
|
|
1543
|
+
}
|
|
1544
|
+
};
|
|
1545
|
+
var WebhookVerificationError = class extends chunkB3QB5WPI_cjs.ClawOpsError {
|
|
1546
|
+
constructor(message = "Webhook \uC11C\uBA85\uC774 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.") {
|
|
1547
|
+
super(message);
|
|
1548
|
+
this.name = "WebhookVerificationError";
|
|
1549
|
+
}
|
|
1550
|
+
};
|
|
1551
|
+
var Webhooks = class _Webhooks {
|
|
1552
|
+
verify(options) {
|
|
1553
|
+
const expected = _Webhooks._computeSignature(options.url, options.params, options.signingKey);
|
|
1554
|
+
const expectedBuf = Buffer.from(expected, "utf-8");
|
|
1555
|
+
const signatureBuf = Buffer.from(options.signature, "utf-8");
|
|
1556
|
+
if (expectedBuf.length !== signatureBuf.length || !crypto.timingSafeEqual(expectedBuf, signatureBuf)) {
|
|
1557
|
+
throw new WebhookVerificationError();
|
|
1558
|
+
}
|
|
1559
|
+
return true;
|
|
1560
|
+
}
|
|
1561
|
+
static _computeSignature(url, params, signingKey) {
|
|
1562
|
+
const sortedParams = Object.keys(params).sort().map((k) => `${k}${params[k]}`).join("");
|
|
1563
|
+
const dataToSign = url + sortedParams;
|
|
1564
|
+
const digest = crypto.createHmac("sha256", signingKey).update(dataToSign, "utf-8").digest();
|
|
1565
|
+
return digest.toString("base64");
|
|
1566
|
+
}
|
|
1567
|
+
};
|
|
1568
|
+
|
|
1569
|
+
// src/client.ts
|
|
1570
|
+
var ClawOps = class extends APIClient {
|
|
1571
|
+
_defaultAccountId;
|
|
1572
|
+
constructor(options = {}) {
|
|
1573
|
+
let apiKey = options.apiKey ?? process.env.CLAWOPS_API_KEY;
|
|
1574
|
+
if (!apiKey) {
|
|
1575
|
+
throw new chunkB3QB5WPI_cjs.ClawOpsError("apiKey\uB97C \uC9C0\uC815\uD558\uAC70\uB098 CLAWOPS_API_KEY \uD658\uACBD\uBCC0\uC218\uB97C \uC124\uC815\uD558\uC138\uC694.");
|
|
1576
|
+
}
|
|
1577
|
+
let accountId = options.accountId ?? process.env.CLAWOPS_ACCOUNT_ID;
|
|
1578
|
+
if (!accountId) {
|
|
1579
|
+
throw new chunkB3QB5WPI_cjs.ClawOpsError("accountId\uB97C \uC9C0\uC815\uD558\uAC70\uB098 CLAWOPS_ACCOUNT_ID \uD658\uACBD\uBCC0\uC218\uB97C \uC124\uC815\uD558\uC138\uC694.");
|
|
1580
|
+
}
|
|
1581
|
+
const baseURL = options.baseURL ?? process.env.CLAWOPS_BASE_URL ?? chunkLLPMUDNE_cjs.DEFAULT_BASE_URL;
|
|
1582
|
+
super({
|
|
1583
|
+
apiKey,
|
|
1584
|
+
baseURL,
|
|
1585
|
+
timeout: options.timeout,
|
|
1586
|
+
maxRetries: options.maxRetries,
|
|
1587
|
+
fetch: options.fetch,
|
|
1588
|
+
defaultHeaders: options.defaultHeaders
|
|
1589
|
+
});
|
|
1590
|
+
this._defaultAccountId = accountId;
|
|
1591
|
+
}
|
|
1592
|
+
get calls() {
|
|
1593
|
+
return new Calls(this, this._defaultAccountId);
|
|
1594
|
+
}
|
|
1595
|
+
get messages() {
|
|
1596
|
+
return new Messages(this, this._defaultAccountId);
|
|
1597
|
+
}
|
|
1598
|
+
get numbers() {
|
|
1599
|
+
return new Numbers(this, this._defaultAccountId);
|
|
1600
|
+
}
|
|
1601
|
+
get sipCredentials() {
|
|
1602
|
+
return new SipCredentials(this, this._defaultAccountId);
|
|
1603
|
+
}
|
|
1604
|
+
get sipEndpoints() {
|
|
1605
|
+
return new SipEndpoints(this, this._defaultAccountId);
|
|
1606
|
+
}
|
|
1607
|
+
get recordings() {
|
|
1608
|
+
return new Recordings(this, this._defaultAccountId);
|
|
1609
|
+
}
|
|
1610
|
+
get webhookLogs() {
|
|
1611
|
+
return new WebhookLogs(this, this._defaultAccountId);
|
|
1612
|
+
}
|
|
1613
|
+
get assignmentLinks() {
|
|
1614
|
+
return new AssignmentLinks(this, this._defaultAccountId);
|
|
1615
|
+
}
|
|
1616
|
+
get blockedRecipients() {
|
|
1617
|
+
return new BlockedRecipients(this, this._defaultAccountId);
|
|
1618
|
+
}
|
|
1619
|
+
/** 문자 발신번호 — 조회·등록·삭제(clawops#1489). */
|
|
1620
|
+
get senderNumbers() {
|
|
1621
|
+
return new SenderNumbers(this, this._defaultAccountId);
|
|
1622
|
+
}
|
|
1623
|
+
/** 카카오 채널·알림톡 템플릿. 발송은 `messages.create({ kakao: … })` 다. */
|
|
1624
|
+
get kakao() {
|
|
1625
|
+
return new Kakao(this, this._defaultAccountId);
|
|
1626
|
+
}
|
|
1627
|
+
get webhooks() {
|
|
1628
|
+
return new Webhooks();
|
|
1629
|
+
}
|
|
1630
|
+
accounts(accountId) {
|
|
1631
|
+
return new AccountContext(this, accountId);
|
|
1632
|
+
}
|
|
1633
|
+
};
|
|
1634
|
+
|
|
1635
|
+
// src/client-default.ts
|
|
1636
|
+
var client_default_default = ClawOps;
|
|
1637
|
+
|
|
1638
|
+
Object.defineProperty(exports, "APIConnectionError", {
|
|
1639
|
+
enumerable: true,
|
|
1640
|
+
get: function () { return chunkB3QB5WPI_cjs.APIConnectionError; }
|
|
1641
|
+
});
|
|
1642
|
+
Object.defineProperty(exports, "APIError", {
|
|
1643
|
+
enumerable: true,
|
|
1644
|
+
get: function () { return chunkB3QB5WPI_cjs.APIError; }
|
|
1645
|
+
});
|
|
1646
|
+
Object.defineProperty(exports, "APIResponseValidationError", {
|
|
1647
|
+
enumerable: true,
|
|
1648
|
+
get: function () { return chunkB3QB5WPI_cjs.APIResponseValidationError; }
|
|
1649
|
+
});
|
|
1650
|
+
Object.defineProperty(exports, "APIStatusError", {
|
|
1651
|
+
enumerable: true,
|
|
1652
|
+
get: function () { return chunkB3QB5WPI_cjs.APIStatusError; }
|
|
1653
|
+
});
|
|
1654
|
+
Object.defineProperty(exports, "APITimeoutError", {
|
|
1655
|
+
enumerable: true,
|
|
1656
|
+
get: function () { return chunkB3QB5WPI_cjs.APITimeoutError; }
|
|
1657
|
+
});
|
|
1658
|
+
Object.defineProperty(exports, "AgentAuthRejectedError", {
|
|
1659
|
+
enumerable: true,
|
|
1660
|
+
get: function () { return chunkB3QB5WPI_cjs.AgentAuthRejectedError; }
|
|
1661
|
+
});
|
|
1662
|
+
Object.defineProperty(exports, "AgentConnectionError", {
|
|
1663
|
+
enumerable: true,
|
|
1664
|
+
get: function () { return chunkB3QB5WPI_cjs.AgentConnectionError; }
|
|
1665
|
+
});
|
|
1666
|
+
Object.defineProperty(exports, "AgentError", {
|
|
1667
|
+
enumerable: true,
|
|
1668
|
+
get: function () { return chunkB3QB5WPI_cjs.AgentError; }
|
|
1669
|
+
});
|
|
1670
|
+
Object.defineProperty(exports, "AuthenticationError", {
|
|
1671
|
+
enumerable: true,
|
|
1672
|
+
get: function () { return chunkB3QB5WPI_cjs.AuthenticationError; }
|
|
1673
|
+
});
|
|
1674
|
+
Object.defineProperty(exports, "BadRequestError", {
|
|
1675
|
+
enumerable: true,
|
|
1676
|
+
get: function () { return chunkB3QB5WPI_cjs.BadRequestError; }
|
|
1677
|
+
});
|
|
1678
|
+
Object.defineProperty(exports, "ClawOpsError", {
|
|
1679
|
+
enumerable: true,
|
|
1680
|
+
get: function () { return chunkB3QB5WPI_cjs.ClawOpsError; }
|
|
1681
|
+
});
|
|
1682
|
+
Object.defineProperty(exports, "ConflictError", {
|
|
1683
|
+
enumerable: true,
|
|
1684
|
+
get: function () { return chunkB3QB5WPI_cjs.ConflictError; }
|
|
1685
|
+
});
|
|
1686
|
+
Object.defineProperty(exports, "InternalServerError", {
|
|
1687
|
+
enumerable: true,
|
|
1688
|
+
get: function () { return chunkB3QB5WPI_cjs.InternalServerError; }
|
|
1689
|
+
});
|
|
1690
|
+
Object.defineProperty(exports, "NotFoundError", {
|
|
1691
|
+
enumerable: true,
|
|
1692
|
+
get: function () { return chunkB3QB5WPI_cjs.NotFoundError; }
|
|
1693
|
+
});
|
|
1694
|
+
Object.defineProperty(exports, "PermissionDeniedError", {
|
|
1695
|
+
enumerable: true,
|
|
1696
|
+
get: function () { return chunkB3QB5WPI_cjs.PermissionDeniedError; }
|
|
1697
|
+
});
|
|
1698
|
+
Object.defineProperty(exports, "RateLimitError", {
|
|
1699
|
+
enumerable: true,
|
|
1700
|
+
get: function () { return chunkB3QB5WPI_cjs.RateLimitError; }
|
|
1701
|
+
});
|
|
1702
|
+
Object.defineProperty(exports, "ServiceUnavailableError", {
|
|
1703
|
+
enumerable: true,
|
|
1704
|
+
get: function () { return chunkB3QB5WPI_cjs.ServiceUnavailableError; }
|
|
1705
|
+
});
|
|
1706
|
+
Object.defineProperty(exports, "SolapiBridgeError", {
|
|
1707
|
+
enumerable: true,
|
|
1708
|
+
get: function () { return chunkB3QB5WPI_cjs.SolapiBridgeError; }
|
|
1709
|
+
});
|
|
1710
|
+
Object.defineProperty(exports, "UnprocessableEntityError", {
|
|
1711
|
+
enumerable: true,
|
|
1712
|
+
get: function () { return chunkB3QB5WPI_cjs.UnprocessableEntityError; }
|
|
1713
|
+
});
|
|
1714
|
+
Object.defineProperty(exports, "VERSION", {
|
|
1715
|
+
enumerable: true,
|
|
1716
|
+
get: function () { return chunkTCIIGMEU_cjs.VERSION; }
|
|
1717
|
+
});
|
|
1718
|
+
exports.APIClient = APIClient;
|
|
1719
|
+
exports.AccountContext = AccountContext;
|
|
1720
|
+
exports.AssignmentLinks = AssignmentLinks;
|
|
1721
|
+
exports.BlockedRecipients = BlockedRecipients;
|
|
1722
|
+
exports.Calls = Calls;
|
|
1723
|
+
exports.ClawOps = ClawOps;
|
|
1724
|
+
exports.Kakao = Kakao;
|
|
1725
|
+
exports.KakaoBrandImages = KakaoBrandImages;
|
|
1726
|
+
exports.KakaoBrandTemplates = KakaoBrandTemplates;
|
|
1727
|
+
exports.KakaoChannels = KakaoChannels;
|
|
1728
|
+
exports.KakaoTemplates = KakaoTemplates;
|
|
1729
|
+
exports.Messages = Messages;
|
|
1730
|
+
exports.Numbers = Numbers;
|
|
1731
|
+
exports.Page = Page;
|
|
1732
|
+
exports.Recordings = Recordings;
|
|
1733
|
+
exports.SenderNumbers = SenderNumbers;
|
|
1734
|
+
exports.SipCredentials = SipCredentials;
|
|
1735
|
+
exports.SipEndpoints = SipEndpoints;
|
|
1736
|
+
exports.WebhookLogs = WebhookLogs;
|
|
1737
|
+
exports.WebhookVerificationError = WebhookVerificationError;
|
|
1738
|
+
exports.Webhooks = Webhooks;
|
|
1739
|
+
exports.default = client_default_default;
|
|
1740
|
+
//# sourceMappingURL=index.cjs.map
|
|
1741
|
+
//# sourceMappingURL=index.cjs.map
|