@unboundcx/sdk 4.13.145 → 4.13.146-security.0
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/README.md +7 -0
- package/base.js +74 -3
- package/index.js +7 -31
- package/lib/refreshInterceptor.js +127 -0
- package/package.json +2 -5
- package/services/layouts.js +4 -13
- package/services/licenses.js +330 -0
- package/services/login.js +21 -0
- package/services/messageTemplates.js +2 -109
- package/services/messaging/EmailTemplatesService.js +2 -10
- package/services/messaging/SmsService.js +3 -0
- package/services/messaging/SmsTemplatesService.js +125 -0
- package/services/messaging.js +2 -0
- package/services/oauth.js +159 -0
- package/services/objects.js +39 -12
- package/services/permissions.js +0 -21
- package/services/phoneNumbers.js +1037 -2
- package/services/recents.js +0 -16
- package/services/taskRouter/MetricsService.js +0 -3
- package/services/taskRouter/TaskRouterService.js +0 -2
- package/services/taskRouter/TaskService.js +10 -70
- package/services/voice.js +25 -47
- package/lib/journeyLayout.js +0 -132
- package/services/journeys/JourneyDraftService.js +0 -92
- package/services/journeys/JourneyGoalsService.js +0 -57
- package/services/journeys/JourneyMembersService.js +0 -246
- package/services/journeys/JourneyTypesService.js +0 -59
- package/services/journeys/JourneyWorklistService.js +0 -74
- package/services/journeys/JourneysService.js +0 -392
- package/services/operatorPanels.js +0 -226
- package/services/parking.js +0 -121
- package/services/phoneNumbers/carrier.js +0 -60
- package/services/phoneNumbers/cnam.js +0 -42
- package/services/phoneNumbers/index.js +0 -27
- package/services/phoneNumbers/order.js +0 -88
- package/services/phoneNumbers/porting-activity.js +0 -289
- package/services/phoneNumbers/porting-orders.js +0 -318
- package/services/phoneNumbers/search.js +0 -181
- package/services/phoneNumbers/update.js +0 -94
- package/services/schedules/SchedulesService.js +0 -232
- package/services/schedules/TimeOffService.js +0 -131
- package/services/skills.js +0 -207
- package/services/taskRouter/QueueService.js +0 -343
- package/services/voicemailDrops.js +0 -268
- package/services/workflowTemplates/WorkflowTemplatesService.js +0 -68
|
@@ -0,0 +1,330 @@
|
|
|
1
|
+
import { internalRequest } from '../base.js';
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* Entitlements / license administration (W2, plan §2 frozen contract).
|
|
5
|
+
* Tenant-admin methods hit `/permissions/*` (admin:license:manage /
|
|
6
|
+
* admin:user:manage, real guard in the controller). Brand-owner methods
|
|
7
|
+
* hit `/permissions/brand/*` (requireBrandOwner + brandId ownership
|
|
8
|
+
* check, 2D). Neither is tenant-writable for seats/overrides/AI --
|
|
9
|
+
* those live under `/internal/authz/*` for account-builder/billing and
|
|
10
|
+
* are not exposed here.
|
|
11
|
+
*/
|
|
12
|
+
export class LicensesService {
|
|
13
|
+
constructor(sdk) {
|
|
14
|
+
this.sdk = sdk;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* Get the tenant's license catalog: license types, seat usage, and the
|
|
19
|
+
* capability catalog.
|
|
20
|
+
* @returns {Promise<Object>} `{ mode, licenseTypes[], capabilities[] }`
|
|
21
|
+
* @example
|
|
22
|
+
* const { licenseTypes } = await sdk.licenses.getCatalog();
|
|
23
|
+
*/
|
|
24
|
+
async getCatalog() {
|
|
25
|
+
return internalRequest(this.sdk, '/permissions/licenses', 'GET');
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
/**
|
|
29
|
+
* List users stuck in `needs_seat` (no free seat at assign time).
|
|
30
|
+
* @param {string} [licenseTypeCode] - Filter to one license type
|
|
31
|
+
* @returns {Promise<Object>} `{ results: [{ userId, licenseTypeCode, source, createdAt }] }`
|
|
32
|
+
* @example
|
|
33
|
+
* const { results } = await sdk.licenses.listNeedsSeat('license.support');
|
|
34
|
+
*/
|
|
35
|
+
async listNeedsSeat(licenseTypeCode) {
|
|
36
|
+
const params = licenseTypeCode ? { query: { licenseTypeCode } } : {};
|
|
37
|
+
return internalRequest(
|
|
38
|
+
this.sdk,
|
|
39
|
+
'/permissions/licenses/needs-seat',
|
|
40
|
+
'GET',
|
|
41
|
+
params,
|
|
42
|
+
);
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* Get one user's licenses and resolved entitlements.
|
|
47
|
+
* @param {string} userId
|
|
48
|
+
* @returns {Promise<Object>} `{ licenses[], capabilities[], disabledCapabilities[], licenseGate }`
|
|
49
|
+
* @example
|
|
50
|
+
* await sdk.licenses.getUserLicenses('user-123');
|
|
51
|
+
*/
|
|
52
|
+
async getUserLicenses(userId) {
|
|
53
|
+
this.sdk.validateParams(
|
|
54
|
+
{ userId },
|
|
55
|
+
{ userId: { type: 'string', required: true } },
|
|
56
|
+
);
|
|
57
|
+
return internalRequest(
|
|
58
|
+
this.sdk,
|
|
59
|
+
`/permissions/users/${userId}/licenses`,
|
|
60
|
+
'GET',
|
|
61
|
+
);
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
/**
|
|
65
|
+
* Assign a license directly to a user. 409s with
|
|
66
|
+
* `code:'seat_limit_reached'` at capacity or `code:'license_type_disabled'`
|
|
67
|
+
* for a disabled type.
|
|
68
|
+
* @param {string} userId
|
|
69
|
+
* @param {string} licenseTypeCode
|
|
70
|
+
* @returns {Promise<Object>} The assigned license row
|
|
71
|
+
* @example
|
|
72
|
+
* await sdk.licenses.assignUserLicense('user-123', 'license.core');
|
|
73
|
+
*/
|
|
74
|
+
async assignUserLicense(userId, licenseTypeCode) {
|
|
75
|
+
this.sdk.validateParams(
|
|
76
|
+
{ userId, licenseTypeCode },
|
|
77
|
+
{
|
|
78
|
+
userId: { type: 'string', required: true },
|
|
79
|
+
licenseTypeCode: { type: 'string', required: true },
|
|
80
|
+
},
|
|
81
|
+
);
|
|
82
|
+
return internalRequest(
|
|
83
|
+
this.sdk,
|
|
84
|
+
`/permissions/users/${userId}/licenses`,
|
|
85
|
+
'POST',
|
|
86
|
+
{ body: { licenseTypeCode } },
|
|
87
|
+
);
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
/**
|
|
91
|
+
* Remove a user's direct license grant (group-sourced grants are
|
|
92
|
+
* unaffected -- see `recomputeUserLicenses`).
|
|
93
|
+
* @param {string} userId
|
|
94
|
+
* @param {string} licenseTypeCode
|
|
95
|
+
* @returns {Promise<Object>}
|
|
96
|
+
* @example
|
|
97
|
+
* await sdk.licenses.removeUserLicense('user-123', 'license.core');
|
|
98
|
+
*/
|
|
99
|
+
async removeUserLicense(userId, licenseTypeCode) {
|
|
100
|
+
this.sdk.validateParams(
|
|
101
|
+
{ userId, licenseTypeCode },
|
|
102
|
+
{
|
|
103
|
+
userId: { type: 'string', required: true },
|
|
104
|
+
licenseTypeCode: { type: 'string', required: true },
|
|
105
|
+
},
|
|
106
|
+
);
|
|
107
|
+
return internalRequest(
|
|
108
|
+
this.sdk,
|
|
109
|
+
`/permissions/users/${userId}/licenses/${licenseTypeCode}`,
|
|
110
|
+
'DELETE',
|
|
111
|
+
);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
/**
|
|
115
|
+
* Get a group's license types (group-sourced grants fan out to members).
|
|
116
|
+
* @param {string} groupId
|
|
117
|
+
* @returns {Promise<Object>} `{ licenseTypeCodes: [] }`
|
|
118
|
+
* @example
|
|
119
|
+
* await sdk.licenses.getGroupLicenses('group-123');
|
|
120
|
+
*/
|
|
121
|
+
async getGroupLicenses(groupId) {
|
|
122
|
+
this.sdk.validateParams(
|
|
123
|
+
{ groupId },
|
|
124
|
+
{ groupId: { type: 'string', required: true } },
|
|
125
|
+
);
|
|
126
|
+
return internalRequest(
|
|
127
|
+
this.sdk,
|
|
128
|
+
`/permissions/groups/${groupId}/licenses`,
|
|
129
|
+
'GET',
|
|
130
|
+
);
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
/**
|
|
134
|
+
* Replace a group's license types. Triggers a `recomputeUserLicenses`
|
|
135
|
+
* fan-out for every member.
|
|
136
|
+
* @param {string} groupId
|
|
137
|
+
* @param {string[]} licenseTypeCodes
|
|
138
|
+
* @returns {Promise<Object>}
|
|
139
|
+
* @example
|
|
140
|
+
* await sdk.licenses.setGroupLicenses('group-123', ['license.core']);
|
|
141
|
+
*/
|
|
142
|
+
async setGroupLicenses(groupId, licenseTypeCodes) {
|
|
143
|
+
this.sdk.validateParams(
|
|
144
|
+
{ groupId, licenseTypeCodes },
|
|
145
|
+
{
|
|
146
|
+
groupId: { type: 'string', required: true },
|
|
147
|
+
licenseTypeCodes: { type: 'array', required: true },
|
|
148
|
+
},
|
|
149
|
+
);
|
|
150
|
+
return internalRequest(
|
|
151
|
+
this.sdk,
|
|
152
|
+
`/permissions/groups/${groupId}/licenses`,
|
|
153
|
+
'PUT',
|
|
154
|
+
{ body: { licenseTypeCodes } },
|
|
155
|
+
);
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
/**
|
|
159
|
+
* Set a user's active/disabled status (W1-3). Disabling bumps the
|
|
160
|
+
* user's token_version and logs them out of every queue.
|
|
161
|
+
* @param {string} userId
|
|
162
|
+
* @param {'active'|'disabled'} status
|
|
163
|
+
* @returns {Promise<Object>}
|
|
164
|
+
* @example
|
|
165
|
+
* await sdk.licenses.setUserStatus('user-123', 'disabled');
|
|
166
|
+
*/
|
|
167
|
+
async setUserStatus(userId, status) {
|
|
168
|
+
this.sdk.validateParams(
|
|
169
|
+
{ userId, status },
|
|
170
|
+
{
|
|
171
|
+
userId: { type: 'string', required: true },
|
|
172
|
+
status: { type: 'string', required: true },
|
|
173
|
+
},
|
|
174
|
+
);
|
|
175
|
+
return internalRequest(
|
|
176
|
+
this.sdk,
|
|
177
|
+
`/permissions/users/${userId}/status`,
|
|
178
|
+
'PUT',
|
|
179
|
+
{ body: { status } },
|
|
180
|
+
);
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
// -- Brand-owner methods (requireBrandOwner; 2D api routes) --------------
|
|
184
|
+
|
|
185
|
+
/**
|
|
186
|
+
* Brand owner: list the tenant accounts under this brand, with their
|
|
187
|
+
* seats and overrides.
|
|
188
|
+
* @returns {Promise<Object>} `{ accounts: [{ id, name, code, aiEnabled, seats[], overrides[] }] }`
|
|
189
|
+
* @example
|
|
190
|
+
* const { accounts } = await sdk.licenses.listBrandAccounts();
|
|
191
|
+
*/
|
|
192
|
+
async listBrandAccounts() {
|
|
193
|
+
return internalRequest(this.sdk, '/permissions/brand/accounts', 'GET');
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
/**
|
|
197
|
+
* Brand owner: get one brand account's entitlements.
|
|
198
|
+
* @param {string} accountId
|
|
199
|
+
* @returns {Promise<Object>} `{ id, name, code, aiEnabled, seats[], overrides[] }`
|
|
200
|
+
* @example
|
|
201
|
+
* await sdk.licenses.getBrandAccountEntitlements('acct-123');
|
|
202
|
+
*/
|
|
203
|
+
async getBrandAccountEntitlements(accountId) {
|
|
204
|
+
this.sdk.validateParams(
|
|
205
|
+
{ accountId },
|
|
206
|
+
{ accountId: { type: 'string', required: true } },
|
|
207
|
+
);
|
|
208
|
+
return internalRequest(
|
|
209
|
+
this.sdk,
|
|
210
|
+
`/permissions/brand/accounts/${accountId}/entitlements`,
|
|
211
|
+
'GET',
|
|
212
|
+
);
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
/**
|
|
216
|
+
* Brand owner: set a brand account's seat pool for one license type.
|
|
217
|
+
* @param {string} accountId
|
|
218
|
+
* @param {string} licenseTypeCode
|
|
219
|
+
* @param {Object} seats
|
|
220
|
+
* @param {number} seats.seatCount
|
|
221
|
+
* @param {boolean} [seats.enabled]
|
|
222
|
+
* @param {boolean} [seats.isDefaultForNewUsers]
|
|
223
|
+
* @returns {Promise<Object>}
|
|
224
|
+
* @example
|
|
225
|
+
* await sdk.licenses.setBrandAccountSeats('acct-123', 'license.core', { seatCount: 25 });
|
|
226
|
+
*/
|
|
227
|
+
async setBrandAccountSeats(
|
|
228
|
+
accountId,
|
|
229
|
+
licenseTypeCode,
|
|
230
|
+
{ seatCount, enabled, isDefaultForNewUsers } = {},
|
|
231
|
+
) {
|
|
232
|
+
this.sdk.validateParams(
|
|
233
|
+
{ accountId, licenseTypeCode, seatCount },
|
|
234
|
+
{
|
|
235
|
+
accountId: { type: 'string', required: true },
|
|
236
|
+
licenseTypeCode: { type: 'string', required: true },
|
|
237
|
+
seatCount: { type: 'number', required: true },
|
|
238
|
+
},
|
|
239
|
+
);
|
|
240
|
+
const body = { seatCount };
|
|
241
|
+
if (enabled !== undefined) body.enabled = enabled;
|
|
242
|
+
if (isDefaultForNewUsers !== undefined)
|
|
243
|
+
body.isDefaultForNewUsers = isDefaultForNewUsers;
|
|
244
|
+
return internalRequest(
|
|
245
|
+
this.sdk,
|
|
246
|
+
`/permissions/brand/accounts/${accountId}/license-seats/${licenseTypeCode}`,
|
|
247
|
+
'PUT',
|
|
248
|
+
{ body },
|
|
249
|
+
);
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
/**
|
|
253
|
+
* Brand owner: enable or disable a capability override for a brand
|
|
254
|
+
* account.
|
|
255
|
+
* @param {string} accountId
|
|
256
|
+
* @param {string} capabilityCode
|
|
257
|
+
* @param {Object} override
|
|
258
|
+
* @param {'enable'|'disable'} override.mode
|
|
259
|
+
* @param {string} [override.reason]
|
|
260
|
+
* @returns {Promise<Object>}
|
|
261
|
+
* @example
|
|
262
|
+
* await sdk.licenses.setBrandAccountOverride('acct-123', 'capability.chat', { mode: 'disable', reason: 'trial ended' });
|
|
263
|
+
*/
|
|
264
|
+
async setBrandAccountOverride(accountId, capabilityCode, { mode, reason } = {}) {
|
|
265
|
+
this.sdk.validateParams(
|
|
266
|
+
{ accountId, capabilityCode, mode },
|
|
267
|
+
{
|
|
268
|
+
accountId: { type: 'string', required: true },
|
|
269
|
+
capabilityCode: { type: 'string', required: true },
|
|
270
|
+
mode: { type: 'string', required: true },
|
|
271
|
+
},
|
|
272
|
+
);
|
|
273
|
+
const body = { mode };
|
|
274
|
+
if (reason !== undefined) body.reason = reason;
|
|
275
|
+
return internalRequest(
|
|
276
|
+
this.sdk,
|
|
277
|
+
`/permissions/brand/accounts/${accountId}/capability-overrides/${capabilityCode}`,
|
|
278
|
+
'PUT',
|
|
279
|
+
{ body },
|
|
280
|
+
);
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
/**
|
|
284
|
+
* Brand owner: remove a capability override, reverting to the license
|
|
285
|
+
* template default.
|
|
286
|
+
* @param {string} accountId
|
|
287
|
+
* @param {string} capabilityCode
|
|
288
|
+
* @returns {Promise<Object>}
|
|
289
|
+
* @example
|
|
290
|
+
* await sdk.licenses.deleteBrandAccountOverride('acct-123', 'capability.chat');
|
|
291
|
+
*/
|
|
292
|
+
async deleteBrandAccountOverride(accountId, capabilityCode) {
|
|
293
|
+
this.sdk.validateParams(
|
|
294
|
+
{ accountId, capabilityCode },
|
|
295
|
+
{
|
|
296
|
+
accountId: { type: 'string', required: true },
|
|
297
|
+
capabilityCode: { type: 'string', required: true },
|
|
298
|
+
},
|
|
299
|
+
);
|
|
300
|
+
return internalRequest(
|
|
301
|
+
this.sdk,
|
|
302
|
+
`/permissions/brand/accounts/${accountId}/capability-overrides/${capabilityCode}`,
|
|
303
|
+
'DELETE',
|
|
304
|
+
);
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
/**
|
|
308
|
+
* Brand owner: turn the account's AI features on/off.
|
|
309
|
+
* @param {string} accountId
|
|
310
|
+
* @param {boolean} enabled
|
|
311
|
+
* @returns {Promise<Object>}
|
|
312
|
+
* @example
|
|
313
|
+
* await sdk.licenses.setBrandAccountAiEnabled('acct-123', true);
|
|
314
|
+
*/
|
|
315
|
+
async setBrandAccountAiEnabled(accountId, enabled) {
|
|
316
|
+
this.sdk.validateParams(
|
|
317
|
+
{ accountId, enabled },
|
|
318
|
+
{
|
|
319
|
+
accountId: { type: 'string', required: true },
|
|
320
|
+
enabled: { type: 'boolean', required: true },
|
|
321
|
+
},
|
|
322
|
+
);
|
|
323
|
+
return internalRequest(
|
|
324
|
+
this.sdk,
|
|
325
|
+
`/permissions/brand/accounts/${accountId}/ai-enabled`,
|
|
326
|
+
'PUT',
|
|
327
|
+
{ body: { enabled } },
|
|
328
|
+
);
|
|
329
|
+
}
|
|
330
|
+
}
|
package/services/login.js
CHANGED
|
@@ -29,14 +29,35 @@ export class LoginService {
|
|
|
29
29
|
}
|
|
30
30
|
}
|
|
31
31
|
|
|
32
|
+
// api#222: bearer clients get refreshToken back on /login too (same
|
|
33
|
+
// contract as /login/refresh) -- seed it onto the sdk instance so
|
|
34
|
+
// autoRefresh has something to send on the very first refresh, and
|
|
35
|
+
// also return it for a caller that manages the token itself.
|
|
36
|
+
if (login?.refreshToken) this.sdk.setRefreshToken(login.refreshToken);
|
|
37
|
+
|
|
32
38
|
return {
|
|
33
39
|
valid: true,
|
|
34
40
|
userId: login.userId,
|
|
35
41
|
namespace: login.namespace,
|
|
36
42
|
url: login.url,
|
|
43
|
+
refreshToken: login.refreshToken,
|
|
37
44
|
};
|
|
38
45
|
}
|
|
39
46
|
|
|
47
|
+
// api#222. Cookie clients: no args -- the refreshToken cookie is sent
|
|
48
|
+
// automatically and the new authToken/refreshToken cookies come back on
|
|
49
|
+
// the response, nothing to apply to the SDK instance. Bearer clients:
|
|
50
|
+
// pass the refresh token string; the response's `token` is returned so
|
|
51
|
+
// the caller (or lib/refreshInterceptor.js) can call sdk.setToken(token).
|
|
52
|
+
// Always forceFetch (true): refresh exists to recover a dead session, so
|
|
53
|
+
// it must never ride a socket transport that itself depends on that
|
|
54
|
+
// session still being alive.
|
|
55
|
+
async refresh(refreshToken) {
|
|
56
|
+
const options = {};
|
|
57
|
+
if (refreshToken) options.body = { refreshToken };
|
|
58
|
+
return internalRequest(this.sdk, '/login/refresh', 'POST', options, true);
|
|
59
|
+
}
|
|
60
|
+
|
|
40
61
|
async logout() {
|
|
41
62
|
const logout = await internalRequest(this.sdk, '/login', 'DELETE', {}, true);
|
|
42
63
|
|
|
@@ -129,8 +129,7 @@ export class MessageTemplatesCrudService {
|
|
|
129
129
|
* @param {string} options.body
|
|
130
130
|
* @param {'draft'|'active'} [options.status]
|
|
131
131
|
* @param {number} [options.sortOrder]
|
|
132
|
-
* @
|
|
133
|
-
* @returns {Promise<Object>} includes `version` (starts at 1; a version row is written on every save)
|
|
132
|
+
* @returns {Promise<Object>}
|
|
134
133
|
*/
|
|
135
134
|
async create(options) {
|
|
136
135
|
this.sdk.validateParams(
|
|
@@ -154,12 +153,9 @@ export class MessageTemplatesCrudService {
|
|
|
154
153
|
}
|
|
155
154
|
|
|
156
155
|
/**
|
|
157
|
-
* Update a stored message template.
|
|
158
|
-
* new row to the version history (a status-only or group-move save does
|
|
159
|
-
* not).
|
|
156
|
+
* Update a stored message template.
|
|
160
157
|
* @param {string} id
|
|
161
158
|
* @param {Object} options
|
|
162
|
-
* @param {Array<{url: string, type: 'image'|'video'|'audio'|'document', name?: string}>} [options.media]
|
|
163
159
|
* @returns {Promise<Object>}
|
|
164
160
|
*/
|
|
165
161
|
async update(id, options) {
|
|
@@ -186,108 +182,6 @@ export class MessageTemplatesCrudService {
|
|
|
186
182
|
'DELETE',
|
|
187
183
|
);
|
|
188
184
|
}
|
|
189
|
-
|
|
190
|
-
/**
|
|
191
|
-
* Preview a template interpolated against a record (or a raw body with
|
|
192
|
-
* no saved template), with unresolved-variable highlighting and SMS
|
|
193
|
-
* character/segment count (journeys-plan.md §6.4). Pass either a saved
|
|
194
|
-
* `templateId` or a raw `body`.
|
|
195
|
-
* @param {Object} options
|
|
196
|
-
* @param {string} [options.templateId]
|
|
197
|
-
* @param {string} [options.body] - raw body when there is no saved template
|
|
198
|
-
* @param {string} [options.peopleId] - record to interpolate against
|
|
199
|
-
* @returns {Promise<{text: string, unresolved: string[], fits: boolean, segments: number}>}
|
|
200
|
-
*/
|
|
201
|
-
async preview({ templateId, body, peopleId } = {}) {
|
|
202
|
-
if (!templateId && !body) {
|
|
203
|
-
throw new Error('preview requires templateId or body');
|
|
204
|
-
}
|
|
205
|
-
const endpoint = templateId
|
|
206
|
-
? `/messageTemplates/templates/${templateId}/preview`
|
|
207
|
-
: '/messageTemplates/templates/preview';
|
|
208
|
-
return internalRequest(this.sdk, endpoint, 'POST', {
|
|
209
|
-
body: { templateId, body, peopleId },
|
|
210
|
-
});
|
|
211
|
-
}
|
|
212
|
-
|
|
213
|
-
/**
|
|
214
|
-
* Send a test SMS of the interpolated template to the caller's own
|
|
215
|
-
* on-file number (never an arbitrary address).
|
|
216
|
-
* @param {string} id
|
|
217
|
-
* @returns {Promise<{sent: boolean, to: string}>}
|
|
218
|
-
*/
|
|
219
|
-
async sendTest(id) {
|
|
220
|
-
this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
|
|
221
|
-
return internalRequest(
|
|
222
|
-
this.sdk,
|
|
223
|
-
`/messageTemplates/templates/${id}/sendTest`,
|
|
224
|
-
'POST',
|
|
225
|
-
);
|
|
226
|
-
}
|
|
227
|
-
|
|
228
|
-
/**
|
|
229
|
-
* "Used by N journeys, M active members" (journeys-plan.md §6.4).
|
|
230
|
-
* @param {string} id
|
|
231
|
-
* @returns {Promise<{journeyCount: number, activeMemberCount: number, journeys: Object[]}>}
|
|
232
|
-
*/
|
|
233
|
-
async usage(id) {
|
|
234
|
-
this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
|
|
235
|
-
return internalRequest(
|
|
236
|
-
this.sdk,
|
|
237
|
-
`/messageTemplates/templates/${id}/usage`,
|
|
238
|
-
'GET',
|
|
239
|
-
);
|
|
240
|
-
}
|
|
241
|
-
}
|
|
242
|
-
|
|
243
|
-
/**
|
|
244
|
-
* Version history for a stored message template (save is live; history +
|
|
245
|
-
* restore). A restore always appends a new version — history is
|
|
246
|
-
* append-only, never a destructive rewrite.
|
|
247
|
-
*/
|
|
248
|
-
export class MessageTemplateVersionsService {
|
|
249
|
-
constructor(sdk) {
|
|
250
|
-
this.sdk = sdk;
|
|
251
|
-
}
|
|
252
|
-
|
|
253
|
-
/**
|
|
254
|
-
* List a template's saved versions, newest first.
|
|
255
|
-
* @param {string} templateId
|
|
256
|
-
* @returns {Promise<Object[]>}
|
|
257
|
-
*/
|
|
258
|
-
async list(templateId) {
|
|
259
|
-
this.sdk.validateParams(
|
|
260
|
-
{ templateId },
|
|
261
|
-
{ templateId: { type: 'string', required: true } },
|
|
262
|
-
);
|
|
263
|
-
return internalRequest(
|
|
264
|
-
this.sdk,
|
|
265
|
-
`/messageTemplates/templates/${templateId}/versions`,
|
|
266
|
-
'GET',
|
|
267
|
-
);
|
|
268
|
-
}
|
|
269
|
-
|
|
270
|
-
/**
|
|
271
|
-
* Restore a prior version — writes a NEW version with that version's
|
|
272
|
-
* content and returns the updated template.
|
|
273
|
-
* @param {string} templateId
|
|
274
|
-
* @param {number} version
|
|
275
|
-
* @returns {Promise<Object>}
|
|
276
|
-
*/
|
|
277
|
-
async restore(templateId, version) {
|
|
278
|
-
this.sdk.validateParams(
|
|
279
|
-
{ templateId, version },
|
|
280
|
-
{
|
|
281
|
-
templateId: { type: 'string', required: true },
|
|
282
|
-
version: { type: 'number', required: true },
|
|
283
|
-
},
|
|
284
|
-
);
|
|
285
|
-
return internalRequest(
|
|
286
|
-
this.sdk,
|
|
287
|
-
`/messageTemplates/templates/${templateId}/versions/${version}/restore`,
|
|
288
|
-
'POST',
|
|
289
|
-
);
|
|
290
|
-
}
|
|
291
185
|
}
|
|
292
186
|
|
|
293
187
|
export class MessageTemplatesService {
|
|
@@ -295,7 +189,6 @@ export class MessageTemplatesService {
|
|
|
295
189
|
this.sdk = sdk;
|
|
296
190
|
this.groups = new MessageTemplateGroupsService(sdk);
|
|
297
191
|
this.templates = new MessageTemplatesCrudService(sdk);
|
|
298
|
-
this.templates.versions = new MessageTemplateVersionsService(sdk);
|
|
299
192
|
}
|
|
300
193
|
|
|
301
194
|
/**
|
|
@@ -22,7 +22,6 @@ export class EmailTemplatesService {
|
|
|
22
22
|
* @param {string} [params.text] - Plain text template body
|
|
23
23
|
* @param {Object} [params.design] - Block-tree design JSON (compiled server-side)
|
|
24
24
|
* @param {string} [params.appearance] - `client` or `marketing` (immutable after create)
|
|
25
|
-
* @param {string} [params.emailType] - `marketing` | `sales` | `transactional` (defaults to `marketing`; separate from `appearance`)
|
|
26
25
|
* @param {boolean} [params.allowOneOff] - Usable as a one-off / compose send
|
|
27
26
|
* @param {boolean} [params.allowCampaign] - Usable in campaigns / journeys
|
|
28
27
|
* @param {string} [params.brandKitId] - Brand kit to apply
|
|
@@ -58,7 +57,6 @@ export class EmailTemplatesService {
|
|
|
58
57
|
variables,
|
|
59
58
|
design,
|
|
60
59
|
appearance,
|
|
61
|
-
emailType,
|
|
62
60
|
allowOneOff,
|
|
63
61
|
allowCampaign,
|
|
64
62
|
brandKitId,
|
|
@@ -74,7 +72,6 @@ export class EmailTemplatesService {
|
|
|
74
72
|
variables: { type: 'array', required: false },
|
|
75
73
|
design: { type: 'object', required: false },
|
|
76
74
|
appearance: { type: 'string', required: false },
|
|
77
|
-
emailType: { type: 'string', required: false },
|
|
78
75
|
allowOneOff: { type: 'boolean', required: false },
|
|
79
76
|
allowCampaign: { type: 'boolean', required: false },
|
|
80
77
|
brandKitId: { type: 'string', required: false },
|
|
@@ -91,7 +88,6 @@ export class EmailTemplatesService {
|
|
|
91
88
|
variables,
|
|
92
89
|
design,
|
|
93
90
|
appearance,
|
|
94
|
-
emailType,
|
|
95
91
|
allowOneOff,
|
|
96
92
|
allowCampaign,
|
|
97
93
|
brandKitId,
|
|
@@ -99,7 +95,7 @@ export class EmailTemplatesService {
|
|
|
99
95
|
}),
|
|
100
96
|
};
|
|
101
97
|
|
|
102
|
-
const result = await internalRequest(this.sdk,
|
|
98
|
+
const result = await internalRequest(this.sdk,
|
|
103
99
|
'/messaging/email/template',
|
|
104
100
|
'POST',
|
|
105
101
|
options,
|
|
@@ -118,7 +114,6 @@ export class EmailTemplatesService {
|
|
|
118
114
|
* @param {string} [params.text] - Plain text template body
|
|
119
115
|
* @param {Object} [params.design] - Block-tree design JSON (compiled server-side)
|
|
120
116
|
* @param {string} [params.appearance] - Usually omit; immutable after create
|
|
121
|
-
* @param {string} [params.emailType] - `marketing` | `sales` | `transactional` (not immutable)
|
|
122
117
|
* @param {boolean} [params.allowOneOff] - Usable as a one-off / compose send
|
|
123
118
|
* @param {boolean} [params.allowCampaign] - Usable in campaigns / journeys
|
|
124
119
|
* @param {string} [params.brandKitId] - Brand kit to apply
|
|
@@ -152,7 +147,6 @@ export class EmailTemplatesService {
|
|
|
152
147
|
variables,
|
|
153
148
|
design,
|
|
154
149
|
appearance,
|
|
155
|
-
emailType,
|
|
156
150
|
allowOneOff,
|
|
157
151
|
allowCampaign,
|
|
158
152
|
brandKitId,
|
|
@@ -170,7 +164,6 @@ export class EmailTemplatesService {
|
|
|
170
164
|
variables: { type: 'array', required: false },
|
|
171
165
|
design: { type: 'object', required: false },
|
|
172
166
|
appearance: { type: 'string', required: false },
|
|
173
|
-
emailType: { type: 'string', required: false },
|
|
174
167
|
allowOneOff: { type: 'boolean', required: false },
|
|
175
168
|
allowCampaign: { type: 'boolean', required: false },
|
|
176
169
|
brandKitId: { type: 'string', required: false },
|
|
@@ -187,7 +180,6 @@ export class EmailTemplatesService {
|
|
|
187
180
|
variables,
|
|
188
181
|
design,
|
|
189
182
|
appearance,
|
|
190
|
-
emailType,
|
|
191
183
|
allowOneOff,
|
|
192
184
|
allowCampaign,
|
|
193
185
|
brandKitId,
|
|
@@ -195,7 +187,7 @@ export class EmailTemplatesService {
|
|
|
195
187
|
}),
|
|
196
188
|
};
|
|
197
189
|
|
|
198
|
-
const result = await internalRequest(this.sdk,
|
|
190
|
+
const result = await internalRequest(this.sdk,
|
|
199
191
|
`/messaging/email/template/${id}`,
|
|
200
192
|
'PUT',
|
|
201
193
|
options,
|