@aws-sdk/client-customer-profiles 3.476.0 → 3.477.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/dist-cjs/protocols/Aws_restJson1.js +318 -716
- package/dist-es/protocols/Aws_restJson1.js +319 -717
- package/package.json +5 -4
|
@@ -1,39 +1,31 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp,
|
|
1
|
+
import { requestBuilder as rb } from "@smithy/core";
|
|
2
|
+
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
|
|
3
3
|
import { CustomerProfilesServiceException as __BaseException } from "../models/CustomerProfilesServiceException";
|
|
4
4
|
import { AccessDeniedException, BadRequestException, InternalServerException, ResourceNotFoundException, ThrottlingException, } from "../models/models_0";
|
|
5
5
|
export const se_AddProfileKeyCommand = async (input, context) => {
|
|
6
|
-
const
|
|
6
|
+
const b = rb(input, context);
|
|
7
7
|
const headers = {
|
|
8
8
|
"content-type": "application/json",
|
|
9
9
|
};
|
|
10
|
-
|
|
11
|
-
|
|
10
|
+
b.bp("/domains/{DomainName}/profiles/keys");
|
|
11
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
12
12
|
let body;
|
|
13
13
|
body = JSON.stringify(take(input, {
|
|
14
14
|
KeyName: [],
|
|
15
15
|
ProfileId: [],
|
|
16
16
|
Values: (_) => _json(_),
|
|
17
17
|
}));
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
hostname,
|
|
21
|
-
port,
|
|
22
|
-
method: "POST",
|
|
23
|
-
headers,
|
|
24
|
-
path: resolvedPath,
|
|
25
|
-
body,
|
|
26
|
-
});
|
|
18
|
+
b.m("POST").h(headers).b(body);
|
|
19
|
+
return b.build();
|
|
27
20
|
};
|
|
28
21
|
export const se_CreateCalculatedAttributeDefinitionCommand = async (input, context) => {
|
|
29
|
-
const
|
|
22
|
+
const b = rb(input, context);
|
|
30
23
|
const headers = {
|
|
31
24
|
"content-type": "application/json",
|
|
32
25
|
};
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
26
|
+
b.bp("/domains/{DomainName}/calculated-attributes/{CalculatedAttributeName}");
|
|
27
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
28
|
+
b.p("CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
37
29
|
let body;
|
|
38
30
|
body = JSON.stringify(take(input, {
|
|
39
31
|
AttributeDetails: (_) => _json(_),
|
|
@@ -43,23 +35,16 @@ export const se_CreateCalculatedAttributeDefinitionCommand = async (input, conte
|
|
|
43
35
|
Statistic: [],
|
|
44
36
|
Tags: (_) => _json(_),
|
|
45
37
|
}));
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
hostname,
|
|
49
|
-
port,
|
|
50
|
-
method: "POST",
|
|
51
|
-
headers,
|
|
52
|
-
path: resolvedPath,
|
|
53
|
-
body,
|
|
54
|
-
});
|
|
38
|
+
b.m("POST").h(headers).b(body);
|
|
39
|
+
return b.build();
|
|
55
40
|
};
|
|
56
41
|
export const se_CreateDomainCommand = async (input, context) => {
|
|
57
|
-
const
|
|
42
|
+
const b = rb(input, context);
|
|
58
43
|
const headers = {
|
|
59
44
|
"content-type": "application/json",
|
|
60
45
|
};
|
|
61
|
-
|
|
62
|
-
|
|
46
|
+
b.bp("/domains/{DomainName}");
|
|
47
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
63
48
|
let body;
|
|
64
49
|
body = JSON.stringify(take(input, {
|
|
65
50
|
DeadLetterQueueUrl: [],
|
|
@@ -69,48 +54,32 @@ export const se_CreateDomainCommand = async (input, context) => {
|
|
|
69
54
|
RuleBasedMatching: (_) => _json(_),
|
|
70
55
|
Tags: (_) => _json(_),
|
|
71
56
|
}));
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
hostname,
|
|
75
|
-
port,
|
|
76
|
-
method: "POST",
|
|
77
|
-
headers,
|
|
78
|
-
path: resolvedPath,
|
|
79
|
-
body,
|
|
80
|
-
});
|
|
57
|
+
b.m("POST").h(headers).b(body);
|
|
58
|
+
return b.build();
|
|
81
59
|
};
|
|
82
60
|
export const se_CreateEventStreamCommand = async (input, context) => {
|
|
83
|
-
const
|
|
61
|
+
const b = rb(input, context);
|
|
84
62
|
const headers = {
|
|
85
63
|
"content-type": "application/json",
|
|
86
64
|
};
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "EventStreamName", () => input.EventStreamName, "{EventStreamName}", false);
|
|
65
|
+
b.bp("/domains/{DomainName}/event-streams/{EventStreamName}");
|
|
66
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
67
|
+
b.p("EventStreamName", () => input.EventStreamName, "{EventStreamName}", false);
|
|
91
68
|
let body;
|
|
92
69
|
body = JSON.stringify(take(input, {
|
|
93
70
|
Tags: (_) => _json(_),
|
|
94
71
|
Uri: [],
|
|
95
72
|
}));
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
hostname,
|
|
99
|
-
port,
|
|
100
|
-
method: "POST",
|
|
101
|
-
headers,
|
|
102
|
-
path: resolvedPath,
|
|
103
|
-
body,
|
|
104
|
-
});
|
|
73
|
+
b.m("POST").h(headers).b(body);
|
|
74
|
+
return b.build();
|
|
105
75
|
};
|
|
106
76
|
export const se_CreateIntegrationWorkflowCommand = async (input, context) => {
|
|
107
|
-
const
|
|
77
|
+
const b = rb(input, context);
|
|
108
78
|
const headers = {
|
|
109
79
|
"content-type": "application/json",
|
|
110
80
|
};
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
81
|
+
b.bp("/domains/{DomainName}/workflows/integrations");
|
|
82
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
114
83
|
let body;
|
|
115
84
|
body = JSON.stringify(take(input, {
|
|
116
85
|
IntegrationConfig: (_) => se_IntegrationConfig(_, context),
|
|
@@ -119,23 +88,16 @@ export const se_CreateIntegrationWorkflowCommand = async (input, context) => {
|
|
|
119
88
|
Tags: (_) => _json(_),
|
|
120
89
|
WorkflowType: [],
|
|
121
90
|
}));
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
hostname,
|
|
125
|
-
port,
|
|
126
|
-
method: "POST",
|
|
127
|
-
headers,
|
|
128
|
-
path: resolvedPath,
|
|
129
|
-
body,
|
|
130
|
-
});
|
|
91
|
+
b.m("POST").h(headers).b(body);
|
|
92
|
+
return b.build();
|
|
131
93
|
};
|
|
132
94
|
export const se_CreateProfileCommand = async (input, context) => {
|
|
133
|
-
const
|
|
95
|
+
const b = rb(input, context);
|
|
134
96
|
const headers = {
|
|
135
97
|
"content-type": "application/json",
|
|
136
98
|
};
|
|
137
|
-
|
|
138
|
-
|
|
99
|
+
b.bp("/domains/{DomainName}/profiles");
|
|
100
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
139
101
|
let body;
|
|
140
102
|
body = JSON.stringify(take(input, {
|
|
141
103
|
AccountNumber: [],
|
|
@@ -162,414 +124,254 @@ export const se_CreateProfileCommand = async (input, context) => {
|
|
|
162
124
|
PhoneNumber: [],
|
|
163
125
|
ShippingAddress: (_) => _json(_),
|
|
164
126
|
}));
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
hostname,
|
|
168
|
-
port,
|
|
169
|
-
method: "POST",
|
|
170
|
-
headers,
|
|
171
|
-
path: resolvedPath,
|
|
172
|
-
body,
|
|
173
|
-
});
|
|
127
|
+
b.m("POST").h(headers).b(body);
|
|
128
|
+
return b.build();
|
|
174
129
|
};
|
|
175
130
|
export const se_DeleteCalculatedAttributeDefinitionCommand = async (input, context) => {
|
|
176
|
-
const
|
|
131
|
+
const b = rb(input, context);
|
|
177
132
|
const headers = {};
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
133
|
+
b.bp("/domains/{DomainName}/calculated-attributes/{CalculatedAttributeName}");
|
|
134
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
135
|
+
b.p("CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
182
136
|
let body;
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
hostname,
|
|
186
|
-
port,
|
|
187
|
-
method: "DELETE",
|
|
188
|
-
headers,
|
|
189
|
-
path: resolvedPath,
|
|
190
|
-
body,
|
|
191
|
-
});
|
|
137
|
+
b.m("DELETE").h(headers).b(body);
|
|
138
|
+
return b.build();
|
|
192
139
|
};
|
|
193
140
|
export const se_DeleteDomainCommand = async (input, context) => {
|
|
194
|
-
const
|
|
141
|
+
const b = rb(input, context);
|
|
195
142
|
const headers = {};
|
|
196
|
-
|
|
197
|
-
|
|
143
|
+
b.bp("/domains/{DomainName}");
|
|
144
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
198
145
|
let body;
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
hostname,
|
|
202
|
-
port,
|
|
203
|
-
method: "DELETE",
|
|
204
|
-
headers,
|
|
205
|
-
path: resolvedPath,
|
|
206
|
-
body,
|
|
207
|
-
});
|
|
146
|
+
b.m("DELETE").h(headers).b(body);
|
|
147
|
+
return b.build();
|
|
208
148
|
};
|
|
209
149
|
export const se_DeleteEventStreamCommand = async (input, context) => {
|
|
210
|
-
const
|
|
150
|
+
const b = rb(input, context);
|
|
211
151
|
const headers = {};
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "EventStreamName", () => input.EventStreamName, "{EventStreamName}", false);
|
|
152
|
+
b.bp("/domains/{DomainName}/event-streams/{EventStreamName}");
|
|
153
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
154
|
+
b.p("EventStreamName", () => input.EventStreamName, "{EventStreamName}", false);
|
|
216
155
|
let body;
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
hostname,
|
|
220
|
-
port,
|
|
221
|
-
method: "DELETE",
|
|
222
|
-
headers,
|
|
223
|
-
path: resolvedPath,
|
|
224
|
-
body,
|
|
225
|
-
});
|
|
156
|
+
b.m("DELETE").h(headers).b(body);
|
|
157
|
+
return b.build();
|
|
226
158
|
};
|
|
227
159
|
export const se_DeleteIntegrationCommand = async (input, context) => {
|
|
228
|
-
const
|
|
160
|
+
const b = rb(input, context);
|
|
229
161
|
const headers = {
|
|
230
162
|
"content-type": "application/json",
|
|
231
163
|
};
|
|
232
|
-
|
|
233
|
-
|
|
164
|
+
b.bp("/domains/{DomainName}/integrations/delete");
|
|
165
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
234
166
|
let body;
|
|
235
167
|
body = JSON.stringify(take(input, {
|
|
236
168
|
Uri: [],
|
|
237
169
|
}));
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
hostname,
|
|
241
|
-
port,
|
|
242
|
-
method: "POST",
|
|
243
|
-
headers,
|
|
244
|
-
path: resolvedPath,
|
|
245
|
-
body,
|
|
246
|
-
});
|
|
170
|
+
b.m("POST").h(headers).b(body);
|
|
171
|
+
return b.build();
|
|
247
172
|
};
|
|
248
173
|
export const se_DeleteProfileCommand = async (input, context) => {
|
|
249
|
-
const
|
|
174
|
+
const b = rb(input, context);
|
|
250
175
|
const headers = {
|
|
251
176
|
"content-type": "application/json",
|
|
252
177
|
};
|
|
253
|
-
|
|
254
|
-
|
|
178
|
+
b.bp("/domains/{DomainName}/profiles/delete");
|
|
179
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
255
180
|
let body;
|
|
256
181
|
body = JSON.stringify(take(input, {
|
|
257
182
|
ProfileId: [],
|
|
258
183
|
}));
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
hostname,
|
|
262
|
-
port,
|
|
263
|
-
method: "POST",
|
|
264
|
-
headers,
|
|
265
|
-
path: resolvedPath,
|
|
266
|
-
body,
|
|
267
|
-
});
|
|
184
|
+
b.m("POST").h(headers).b(body);
|
|
185
|
+
return b.build();
|
|
268
186
|
};
|
|
269
187
|
export const se_DeleteProfileKeyCommand = async (input, context) => {
|
|
270
|
-
const
|
|
188
|
+
const b = rb(input, context);
|
|
271
189
|
const headers = {
|
|
272
190
|
"content-type": "application/json",
|
|
273
191
|
};
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
192
|
+
b.bp("/domains/{DomainName}/profiles/keys/delete");
|
|
193
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
277
194
|
let body;
|
|
278
195
|
body = JSON.stringify(take(input, {
|
|
279
196
|
KeyName: [],
|
|
280
197
|
ProfileId: [],
|
|
281
198
|
Values: (_) => _json(_),
|
|
282
199
|
}));
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
hostname,
|
|
286
|
-
port,
|
|
287
|
-
method: "POST",
|
|
288
|
-
headers,
|
|
289
|
-
path: resolvedPath,
|
|
290
|
-
body,
|
|
291
|
-
});
|
|
200
|
+
b.m("POST").h(headers).b(body);
|
|
201
|
+
return b.build();
|
|
292
202
|
};
|
|
293
203
|
export const se_DeleteProfileObjectCommand = async (input, context) => {
|
|
294
|
-
const
|
|
204
|
+
const b = rb(input, context);
|
|
295
205
|
const headers = {
|
|
296
206
|
"content-type": "application/json",
|
|
297
207
|
};
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
208
|
+
b.bp("/domains/{DomainName}/profiles/objects/delete");
|
|
209
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
301
210
|
let body;
|
|
302
211
|
body = JSON.stringify(take(input, {
|
|
303
212
|
ObjectTypeName: [],
|
|
304
213
|
ProfileId: [],
|
|
305
214
|
ProfileObjectUniqueKey: [],
|
|
306
215
|
}));
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
hostname,
|
|
310
|
-
port,
|
|
311
|
-
method: "POST",
|
|
312
|
-
headers,
|
|
313
|
-
path: resolvedPath,
|
|
314
|
-
body,
|
|
315
|
-
});
|
|
216
|
+
b.m("POST").h(headers).b(body);
|
|
217
|
+
return b.build();
|
|
316
218
|
};
|
|
317
219
|
export const se_DeleteProfileObjectTypeCommand = async (input, context) => {
|
|
318
|
-
const
|
|
220
|
+
const b = rb(input, context);
|
|
319
221
|
const headers = {};
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ObjectTypeName", () => input.ObjectTypeName, "{ObjectTypeName}", false);
|
|
222
|
+
b.bp("/domains/{DomainName}/object-types/{ObjectTypeName}");
|
|
223
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
224
|
+
b.p("ObjectTypeName", () => input.ObjectTypeName, "{ObjectTypeName}", false);
|
|
324
225
|
let body;
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
hostname,
|
|
328
|
-
port,
|
|
329
|
-
method: "DELETE",
|
|
330
|
-
headers,
|
|
331
|
-
path: resolvedPath,
|
|
332
|
-
body,
|
|
333
|
-
});
|
|
226
|
+
b.m("DELETE").h(headers).b(body);
|
|
227
|
+
return b.build();
|
|
334
228
|
};
|
|
335
229
|
export const se_DeleteWorkflowCommand = async (input, context) => {
|
|
336
|
-
const
|
|
230
|
+
const b = rb(input, context);
|
|
337
231
|
const headers = {};
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "WorkflowId", () => input.WorkflowId, "{WorkflowId}", false);
|
|
232
|
+
b.bp("/domains/{DomainName}/workflows/{WorkflowId}");
|
|
233
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
234
|
+
b.p("WorkflowId", () => input.WorkflowId, "{WorkflowId}", false);
|
|
342
235
|
let body;
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
hostname,
|
|
346
|
-
port,
|
|
347
|
-
method: "DELETE",
|
|
348
|
-
headers,
|
|
349
|
-
path: resolvedPath,
|
|
350
|
-
body,
|
|
351
|
-
});
|
|
236
|
+
b.m("DELETE").h(headers).b(body);
|
|
237
|
+
return b.build();
|
|
352
238
|
};
|
|
353
239
|
export const se_DetectProfileObjectTypeCommand = async (input, context) => {
|
|
354
|
-
const
|
|
240
|
+
const b = rb(input, context);
|
|
355
241
|
const headers = {
|
|
356
242
|
"content-type": "application/json",
|
|
357
243
|
};
|
|
358
|
-
|
|
359
|
-
|
|
244
|
+
b.bp("/domains/{DomainName}/detect/object-types");
|
|
245
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
360
246
|
let body;
|
|
361
247
|
body = JSON.stringify(take(input, {
|
|
362
248
|
Objects: (_) => _json(_),
|
|
363
249
|
}));
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
hostname,
|
|
367
|
-
port,
|
|
368
|
-
method: "POST",
|
|
369
|
-
headers,
|
|
370
|
-
path: resolvedPath,
|
|
371
|
-
body,
|
|
372
|
-
});
|
|
250
|
+
b.m("POST").h(headers).b(body);
|
|
251
|
+
return b.build();
|
|
373
252
|
};
|
|
374
253
|
export const se_GetAutoMergingPreviewCommand = async (input, context) => {
|
|
375
|
-
const
|
|
254
|
+
const b = rb(input, context);
|
|
376
255
|
const headers = {
|
|
377
256
|
"content-type": "application/json",
|
|
378
257
|
};
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
258
|
+
b.bp("/domains/{DomainName}/identity-resolution-jobs/auto-merging-preview");
|
|
259
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
382
260
|
let body;
|
|
383
261
|
body = JSON.stringify(take(input, {
|
|
384
262
|
ConflictResolution: (_) => _json(_),
|
|
385
263
|
Consolidation: (_) => _json(_),
|
|
386
264
|
MinAllowedConfidenceScoreForMerging: (_) => __serializeFloat(_),
|
|
387
265
|
}));
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
hostname,
|
|
391
|
-
port,
|
|
392
|
-
method: "POST",
|
|
393
|
-
headers,
|
|
394
|
-
path: resolvedPath,
|
|
395
|
-
body,
|
|
396
|
-
});
|
|
266
|
+
b.m("POST").h(headers).b(body);
|
|
267
|
+
return b.build();
|
|
397
268
|
};
|
|
398
269
|
export const se_GetCalculatedAttributeDefinitionCommand = async (input, context) => {
|
|
399
|
-
const
|
|
270
|
+
const b = rb(input, context);
|
|
400
271
|
const headers = {};
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
272
|
+
b.bp("/domains/{DomainName}/calculated-attributes/{CalculatedAttributeName}");
|
|
273
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
274
|
+
b.p("CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
405
275
|
let body;
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
hostname,
|
|
409
|
-
port,
|
|
410
|
-
method: "GET",
|
|
411
|
-
headers,
|
|
412
|
-
path: resolvedPath,
|
|
413
|
-
body,
|
|
414
|
-
});
|
|
276
|
+
b.m("GET").h(headers).b(body);
|
|
277
|
+
return b.build();
|
|
415
278
|
};
|
|
416
279
|
export const se_GetCalculatedAttributeForProfileCommand = async (input, context) => {
|
|
417
|
-
const
|
|
280
|
+
const b = rb(input, context);
|
|
418
281
|
const headers = {};
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
282
|
+
b.bp("/domains/{DomainName}/profile/{ProfileId}/calculated-attributes/{CalculatedAttributeName}");
|
|
283
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
284
|
+
b.p("ProfileId", () => input.ProfileId, "{ProfileId}", false);
|
|
285
|
+
b.p("CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
424
286
|
let body;
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
hostname,
|
|
428
|
-
port,
|
|
429
|
-
method: "GET",
|
|
430
|
-
headers,
|
|
431
|
-
path: resolvedPath,
|
|
432
|
-
body,
|
|
433
|
-
});
|
|
287
|
+
b.m("GET").h(headers).b(body);
|
|
288
|
+
return b.build();
|
|
434
289
|
};
|
|
435
290
|
export const se_GetDomainCommand = async (input, context) => {
|
|
436
|
-
const
|
|
291
|
+
const b = rb(input, context);
|
|
437
292
|
const headers = {};
|
|
438
|
-
|
|
439
|
-
|
|
293
|
+
b.bp("/domains/{DomainName}");
|
|
294
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
440
295
|
let body;
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
hostname,
|
|
444
|
-
port,
|
|
445
|
-
method: "GET",
|
|
446
|
-
headers,
|
|
447
|
-
path: resolvedPath,
|
|
448
|
-
body,
|
|
449
|
-
});
|
|
296
|
+
b.m("GET").h(headers).b(body);
|
|
297
|
+
return b.build();
|
|
450
298
|
};
|
|
451
299
|
export const se_GetEventStreamCommand = async (input, context) => {
|
|
452
|
-
const
|
|
300
|
+
const b = rb(input, context);
|
|
453
301
|
const headers = {};
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "EventStreamName", () => input.EventStreamName, "{EventStreamName}", false);
|
|
302
|
+
b.bp("/domains/{DomainName}/event-streams/{EventStreamName}");
|
|
303
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
304
|
+
b.p("EventStreamName", () => input.EventStreamName, "{EventStreamName}", false);
|
|
458
305
|
let body;
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
hostname,
|
|
462
|
-
port,
|
|
463
|
-
method: "GET",
|
|
464
|
-
headers,
|
|
465
|
-
path: resolvedPath,
|
|
466
|
-
body,
|
|
467
|
-
});
|
|
306
|
+
b.m("GET").h(headers).b(body);
|
|
307
|
+
return b.build();
|
|
468
308
|
};
|
|
469
309
|
export const se_GetIdentityResolutionJobCommand = async (input, context) => {
|
|
470
|
-
const
|
|
310
|
+
const b = rb(input, context);
|
|
471
311
|
const headers = {};
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
|
|
312
|
+
b.bp("/domains/{DomainName}/identity-resolution-jobs/{JobId}");
|
|
313
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
314
|
+
b.p("JobId", () => input.JobId, "{JobId}", false);
|
|
476
315
|
let body;
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
hostname,
|
|
480
|
-
port,
|
|
481
|
-
method: "GET",
|
|
482
|
-
headers,
|
|
483
|
-
path: resolvedPath,
|
|
484
|
-
body,
|
|
485
|
-
});
|
|
316
|
+
b.m("GET").h(headers).b(body);
|
|
317
|
+
return b.build();
|
|
486
318
|
};
|
|
487
319
|
export const se_GetIntegrationCommand = async (input, context) => {
|
|
488
|
-
const
|
|
320
|
+
const b = rb(input, context);
|
|
489
321
|
const headers = {
|
|
490
322
|
"content-type": "application/json",
|
|
491
323
|
};
|
|
492
|
-
|
|
493
|
-
|
|
324
|
+
b.bp("/domains/{DomainName}/integrations");
|
|
325
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
494
326
|
let body;
|
|
495
327
|
body = JSON.stringify(take(input, {
|
|
496
328
|
Uri: [],
|
|
497
329
|
}));
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
hostname,
|
|
501
|
-
port,
|
|
502
|
-
method: "POST",
|
|
503
|
-
headers,
|
|
504
|
-
path: resolvedPath,
|
|
505
|
-
body,
|
|
506
|
-
});
|
|
330
|
+
b.m("POST").h(headers).b(body);
|
|
331
|
+
return b.build();
|
|
507
332
|
};
|
|
508
333
|
export const se_GetMatchesCommand = async (input, context) => {
|
|
509
|
-
const
|
|
334
|
+
const b = rb(input, context);
|
|
510
335
|
const headers = {};
|
|
511
|
-
|
|
512
|
-
|
|
336
|
+
b.bp("/domains/{DomainName}/matches");
|
|
337
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
513
338
|
const query = map({
|
|
514
|
-
|
|
515
|
-
|
|
339
|
+
[_nt]: [, input[_NT]],
|
|
340
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
516
341
|
});
|
|
517
342
|
let body;
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
hostname,
|
|
521
|
-
port,
|
|
522
|
-
method: "GET",
|
|
523
|
-
headers,
|
|
524
|
-
path: resolvedPath,
|
|
525
|
-
query,
|
|
526
|
-
body,
|
|
527
|
-
});
|
|
343
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
344
|
+
return b.build();
|
|
528
345
|
};
|
|
529
346
|
export const se_GetProfileObjectTypeCommand = async (input, context) => {
|
|
530
|
-
const
|
|
347
|
+
const b = rb(input, context);
|
|
531
348
|
const headers = {};
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ObjectTypeName", () => input.ObjectTypeName, "{ObjectTypeName}", false);
|
|
349
|
+
b.bp("/domains/{DomainName}/object-types/{ObjectTypeName}");
|
|
350
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
351
|
+
b.p("ObjectTypeName", () => input.ObjectTypeName, "{ObjectTypeName}", false);
|
|
536
352
|
let body;
|
|
537
|
-
|
|
538
|
-
|
|
539
|
-
hostname,
|
|
540
|
-
port,
|
|
541
|
-
method: "GET",
|
|
542
|
-
headers,
|
|
543
|
-
path: resolvedPath,
|
|
544
|
-
body,
|
|
545
|
-
});
|
|
353
|
+
b.m("GET").h(headers).b(body);
|
|
354
|
+
return b.build();
|
|
546
355
|
};
|
|
547
356
|
export const se_GetProfileObjectTypeTemplateCommand = async (input, context) => {
|
|
548
|
-
const
|
|
357
|
+
const b = rb(input, context);
|
|
549
358
|
const headers = {};
|
|
550
|
-
|
|
551
|
-
|
|
359
|
+
b.bp("/templates/{TemplateId}");
|
|
360
|
+
b.p("TemplateId", () => input.TemplateId, "{TemplateId}", false);
|
|
552
361
|
let body;
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
hostname,
|
|
556
|
-
port,
|
|
557
|
-
method: "GET",
|
|
558
|
-
headers,
|
|
559
|
-
path: resolvedPath,
|
|
560
|
-
body,
|
|
561
|
-
});
|
|
362
|
+
b.m("GET").h(headers).b(body);
|
|
363
|
+
return b.build();
|
|
562
364
|
};
|
|
563
365
|
export const se_GetSimilarProfilesCommand = async (input, context) => {
|
|
564
|
-
const
|
|
366
|
+
const b = rb(input, context);
|
|
565
367
|
const headers = {
|
|
566
368
|
"content-type": "application/json",
|
|
567
369
|
};
|
|
568
|
-
|
|
569
|
-
|
|
370
|
+
b.bp("/domains/{DomainName}/matches");
|
|
371
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
570
372
|
const query = map({
|
|
571
|
-
|
|
572
|
-
|
|
373
|
+
[_nt]: [, input[_NT]],
|
|
374
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
573
375
|
});
|
|
574
376
|
let body;
|
|
575
377
|
body = JSON.stringify(take(input, {
|
|
@@ -577,224 +379,140 @@ export const se_GetSimilarProfilesCommand = async (input, context) => {
|
|
|
577
379
|
SearchKey: [],
|
|
578
380
|
SearchValue: [],
|
|
579
381
|
}));
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
hostname,
|
|
583
|
-
port,
|
|
584
|
-
method: "POST",
|
|
585
|
-
headers,
|
|
586
|
-
path: resolvedPath,
|
|
587
|
-
query,
|
|
588
|
-
body,
|
|
589
|
-
});
|
|
382
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
383
|
+
return b.build();
|
|
590
384
|
};
|
|
591
385
|
export const se_GetWorkflowCommand = async (input, context) => {
|
|
592
|
-
const
|
|
386
|
+
const b = rb(input, context);
|
|
593
387
|
const headers = {};
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "WorkflowId", () => input.WorkflowId, "{WorkflowId}", false);
|
|
388
|
+
b.bp("/domains/{DomainName}/workflows/{WorkflowId}");
|
|
389
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
390
|
+
b.p("WorkflowId", () => input.WorkflowId, "{WorkflowId}", false);
|
|
598
391
|
let body;
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
hostname,
|
|
602
|
-
port,
|
|
603
|
-
method: "GET",
|
|
604
|
-
headers,
|
|
605
|
-
path: resolvedPath,
|
|
606
|
-
body,
|
|
607
|
-
});
|
|
392
|
+
b.m("GET").h(headers).b(body);
|
|
393
|
+
return b.build();
|
|
608
394
|
};
|
|
609
395
|
export const se_GetWorkflowStepsCommand = async (input, context) => {
|
|
610
|
-
const
|
|
396
|
+
const b = rb(input, context);
|
|
611
397
|
const headers = {};
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "WorkflowId", () => input.WorkflowId, "{WorkflowId}", false);
|
|
398
|
+
b.bp("/domains/{DomainName}/workflows/{WorkflowId}/steps");
|
|
399
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
400
|
+
b.p("WorkflowId", () => input.WorkflowId, "{WorkflowId}", false);
|
|
616
401
|
const query = map({
|
|
617
|
-
|
|
618
|
-
|
|
402
|
+
[_nt]: [, input[_NT]],
|
|
403
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
619
404
|
});
|
|
620
405
|
let body;
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
hostname,
|
|
624
|
-
port,
|
|
625
|
-
method: "GET",
|
|
626
|
-
headers,
|
|
627
|
-
path: resolvedPath,
|
|
628
|
-
query,
|
|
629
|
-
body,
|
|
630
|
-
});
|
|
406
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
407
|
+
return b.build();
|
|
631
408
|
};
|
|
632
409
|
export const se_ListAccountIntegrationsCommand = async (input, context) => {
|
|
633
|
-
const
|
|
410
|
+
const b = rb(input, context);
|
|
634
411
|
const headers = {
|
|
635
412
|
"content-type": "application/json",
|
|
636
413
|
};
|
|
637
|
-
|
|
414
|
+
b.bp("/integrations");
|
|
638
415
|
const query = map({
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
|
|
416
|
+
[_nt]: [, input[_NT]],
|
|
417
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
418
|
+
[_ih]: [() => input.IncludeHidden !== void 0, () => input[_IH].toString()],
|
|
642
419
|
});
|
|
643
420
|
let body;
|
|
644
421
|
body = JSON.stringify(take(input, {
|
|
645
422
|
Uri: [],
|
|
646
423
|
}));
|
|
647
|
-
|
|
648
|
-
|
|
649
|
-
hostname,
|
|
650
|
-
port,
|
|
651
|
-
method: "POST",
|
|
652
|
-
headers,
|
|
653
|
-
path: resolvedPath,
|
|
654
|
-
query,
|
|
655
|
-
body,
|
|
656
|
-
});
|
|
424
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
425
|
+
return b.build();
|
|
657
426
|
};
|
|
658
427
|
export const se_ListCalculatedAttributeDefinitionsCommand = async (input, context) => {
|
|
659
|
-
const
|
|
428
|
+
const b = rb(input, context);
|
|
660
429
|
const headers = {};
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
430
|
+
b.bp("/domains/{DomainName}/calculated-attributes");
|
|
431
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
664
432
|
const query = map({
|
|
665
|
-
|
|
666
|
-
|
|
433
|
+
[_nt]: [, input[_NT]],
|
|
434
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
667
435
|
});
|
|
668
436
|
let body;
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
hostname,
|
|
672
|
-
port,
|
|
673
|
-
method: "GET",
|
|
674
|
-
headers,
|
|
675
|
-
path: resolvedPath,
|
|
676
|
-
query,
|
|
677
|
-
body,
|
|
678
|
-
});
|
|
437
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
438
|
+
return b.build();
|
|
679
439
|
};
|
|
680
440
|
export const se_ListCalculatedAttributesForProfileCommand = async (input, context) => {
|
|
681
|
-
const
|
|
441
|
+
const b = rb(input, context);
|
|
682
442
|
const headers = {};
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ProfileId", () => input.ProfileId, "{ProfileId}", false);
|
|
443
|
+
b.bp("/domains/{DomainName}/profile/{ProfileId}/calculated-attributes");
|
|
444
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
445
|
+
b.p("ProfileId", () => input.ProfileId, "{ProfileId}", false);
|
|
687
446
|
const query = map({
|
|
688
|
-
|
|
689
|
-
|
|
447
|
+
[_nt]: [, input[_NT]],
|
|
448
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
690
449
|
});
|
|
691
450
|
let body;
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
hostname,
|
|
695
|
-
port,
|
|
696
|
-
method: "GET",
|
|
697
|
-
headers,
|
|
698
|
-
path: resolvedPath,
|
|
699
|
-
query,
|
|
700
|
-
body,
|
|
701
|
-
});
|
|
451
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
452
|
+
return b.build();
|
|
702
453
|
};
|
|
703
454
|
export const se_ListDomainsCommand = async (input, context) => {
|
|
704
|
-
const
|
|
455
|
+
const b = rb(input, context);
|
|
705
456
|
const headers = {};
|
|
706
|
-
|
|
457
|
+
b.bp("/domains");
|
|
707
458
|
const query = map({
|
|
708
|
-
|
|
709
|
-
|
|
459
|
+
[_nt]: [, input[_NT]],
|
|
460
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
710
461
|
});
|
|
711
462
|
let body;
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
hostname,
|
|
715
|
-
port,
|
|
716
|
-
method: "GET",
|
|
717
|
-
headers,
|
|
718
|
-
path: resolvedPath,
|
|
719
|
-
query,
|
|
720
|
-
body,
|
|
721
|
-
});
|
|
463
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
464
|
+
return b.build();
|
|
722
465
|
};
|
|
723
466
|
export const se_ListEventStreamsCommand = async (input, context) => {
|
|
724
|
-
const
|
|
467
|
+
const b = rb(input, context);
|
|
725
468
|
const headers = {};
|
|
726
|
-
|
|
727
|
-
|
|
469
|
+
b.bp("/domains/{DomainName}/event-streams");
|
|
470
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
728
471
|
const query = map({
|
|
729
|
-
|
|
730
|
-
|
|
472
|
+
[_nt]: [, input[_NT]],
|
|
473
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
731
474
|
});
|
|
732
475
|
let body;
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
hostname,
|
|
736
|
-
port,
|
|
737
|
-
method: "GET",
|
|
738
|
-
headers,
|
|
739
|
-
path: resolvedPath,
|
|
740
|
-
query,
|
|
741
|
-
body,
|
|
742
|
-
});
|
|
476
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
477
|
+
return b.build();
|
|
743
478
|
};
|
|
744
479
|
export const se_ListIdentityResolutionJobsCommand = async (input, context) => {
|
|
745
|
-
const
|
|
480
|
+
const b = rb(input, context);
|
|
746
481
|
const headers = {};
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
482
|
+
b.bp("/domains/{DomainName}/identity-resolution-jobs");
|
|
483
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
750
484
|
const query = map({
|
|
751
|
-
|
|
752
|
-
|
|
485
|
+
[_nt]: [, input[_NT]],
|
|
486
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
753
487
|
});
|
|
754
488
|
let body;
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
hostname,
|
|
758
|
-
port,
|
|
759
|
-
method: "GET",
|
|
760
|
-
headers,
|
|
761
|
-
path: resolvedPath,
|
|
762
|
-
query,
|
|
763
|
-
body,
|
|
764
|
-
});
|
|
489
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
490
|
+
return b.build();
|
|
765
491
|
};
|
|
766
492
|
export const se_ListIntegrationsCommand = async (input, context) => {
|
|
767
|
-
const
|
|
493
|
+
const b = rb(input, context);
|
|
768
494
|
const headers = {};
|
|
769
|
-
|
|
770
|
-
|
|
495
|
+
b.bp("/domains/{DomainName}/integrations");
|
|
496
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
771
497
|
const query = map({
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
498
|
+
[_nt]: [, input[_NT]],
|
|
499
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
500
|
+
[_ih]: [() => input.IncludeHidden !== void 0, () => input[_IH].toString()],
|
|
775
501
|
});
|
|
776
502
|
let body;
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
hostname,
|
|
780
|
-
port,
|
|
781
|
-
method: "GET",
|
|
782
|
-
headers,
|
|
783
|
-
path: resolvedPath,
|
|
784
|
-
query,
|
|
785
|
-
body,
|
|
786
|
-
});
|
|
503
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
504
|
+
return b.build();
|
|
787
505
|
};
|
|
788
506
|
export const se_ListProfileObjectsCommand = async (input, context) => {
|
|
789
|
-
const
|
|
507
|
+
const b = rb(input, context);
|
|
790
508
|
const headers = {
|
|
791
509
|
"content-type": "application/json",
|
|
792
510
|
};
|
|
793
|
-
|
|
794
|
-
|
|
511
|
+
b.bp("/domains/{DomainName}/profiles/objects");
|
|
512
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
795
513
|
const query = map({
|
|
796
|
-
|
|
797
|
-
|
|
514
|
+
[_nt]: [, input[_NT]],
|
|
515
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
798
516
|
});
|
|
799
517
|
let body;
|
|
800
518
|
body = JSON.stringify(take(input, {
|
|
@@ -802,106 +520,66 @@ export const se_ListProfileObjectsCommand = async (input, context) => {
|
|
|
802
520
|
ObjectTypeName: [],
|
|
803
521
|
ProfileId: [],
|
|
804
522
|
}));
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
hostname,
|
|
808
|
-
port,
|
|
809
|
-
method: "POST",
|
|
810
|
-
headers,
|
|
811
|
-
path: resolvedPath,
|
|
812
|
-
query,
|
|
813
|
-
body,
|
|
814
|
-
});
|
|
523
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
524
|
+
return b.build();
|
|
815
525
|
};
|
|
816
526
|
export const se_ListProfileObjectTypesCommand = async (input, context) => {
|
|
817
|
-
const
|
|
527
|
+
const b = rb(input, context);
|
|
818
528
|
const headers = {};
|
|
819
|
-
|
|
820
|
-
|
|
529
|
+
b.bp("/domains/{DomainName}/object-types");
|
|
530
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
821
531
|
const query = map({
|
|
822
|
-
|
|
823
|
-
|
|
532
|
+
[_nt]: [, input[_NT]],
|
|
533
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
824
534
|
});
|
|
825
535
|
let body;
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
hostname,
|
|
829
|
-
port,
|
|
830
|
-
method: "GET",
|
|
831
|
-
headers,
|
|
832
|
-
path: resolvedPath,
|
|
833
|
-
query,
|
|
834
|
-
body,
|
|
835
|
-
});
|
|
536
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
537
|
+
return b.build();
|
|
836
538
|
};
|
|
837
539
|
export const se_ListProfileObjectTypeTemplatesCommand = async (input, context) => {
|
|
838
|
-
const
|
|
540
|
+
const b = rb(input, context);
|
|
839
541
|
const headers = {};
|
|
840
|
-
|
|
542
|
+
b.bp("/templates");
|
|
841
543
|
const query = map({
|
|
842
|
-
|
|
843
|
-
|
|
544
|
+
[_nt]: [, input[_NT]],
|
|
545
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
844
546
|
});
|
|
845
547
|
let body;
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
hostname,
|
|
849
|
-
port,
|
|
850
|
-
method: "GET",
|
|
851
|
-
headers,
|
|
852
|
-
path: resolvedPath,
|
|
853
|
-
query,
|
|
854
|
-
body,
|
|
855
|
-
});
|
|
548
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
549
|
+
return b.build();
|
|
856
550
|
};
|
|
857
551
|
export const se_ListRuleBasedMatchesCommand = async (input, context) => {
|
|
858
|
-
const
|
|
552
|
+
const b = rb(input, context);
|
|
859
553
|
const headers = {};
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
554
|
+
b.bp("/domains/{DomainName}/profiles/ruleBasedMatches");
|
|
555
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
863
556
|
const query = map({
|
|
864
|
-
|
|
865
|
-
|
|
557
|
+
[_nt]: [, input[_NT]],
|
|
558
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
866
559
|
});
|
|
867
560
|
let body;
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
hostname,
|
|
871
|
-
port,
|
|
872
|
-
method: "GET",
|
|
873
|
-
headers,
|
|
874
|
-
path: resolvedPath,
|
|
875
|
-
query,
|
|
876
|
-
body,
|
|
877
|
-
});
|
|
561
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
562
|
+
return b.build();
|
|
878
563
|
};
|
|
879
564
|
export const se_ListTagsForResourceCommand = async (input, context) => {
|
|
880
|
-
const
|
|
565
|
+
const b = rb(input, context);
|
|
881
566
|
const headers = {};
|
|
882
|
-
|
|
883
|
-
|
|
567
|
+
b.bp("/tags/{resourceArn}");
|
|
568
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
884
569
|
let body;
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
hostname,
|
|
888
|
-
port,
|
|
889
|
-
method: "GET",
|
|
890
|
-
headers,
|
|
891
|
-
path: resolvedPath,
|
|
892
|
-
body,
|
|
893
|
-
});
|
|
570
|
+
b.m("GET").h(headers).b(body);
|
|
571
|
+
return b.build();
|
|
894
572
|
};
|
|
895
573
|
export const se_ListWorkflowsCommand = async (input, context) => {
|
|
896
|
-
const
|
|
574
|
+
const b = rb(input, context);
|
|
897
575
|
const headers = {
|
|
898
576
|
"content-type": "application/json",
|
|
899
577
|
};
|
|
900
|
-
|
|
901
|
-
|
|
578
|
+
b.bp("/domains/{DomainName}/workflows");
|
|
579
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
902
580
|
const query = map({
|
|
903
|
-
|
|
904
|
-
|
|
581
|
+
[_nt]: [, input[_NT]],
|
|
582
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
905
583
|
});
|
|
906
584
|
let body;
|
|
907
585
|
body = JSON.stringify(take(input, {
|
|
@@ -910,48 +588,32 @@ export const se_ListWorkflowsCommand = async (input, context) => {
|
|
|
910
588
|
Status: [],
|
|
911
589
|
WorkflowType: [],
|
|
912
590
|
}));
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
hostname,
|
|
916
|
-
port,
|
|
917
|
-
method: "POST",
|
|
918
|
-
headers,
|
|
919
|
-
path: resolvedPath,
|
|
920
|
-
query,
|
|
921
|
-
body,
|
|
922
|
-
});
|
|
591
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
592
|
+
return b.build();
|
|
923
593
|
};
|
|
924
594
|
export const se_MergeProfilesCommand = async (input, context) => {
|
|
925
|
-
const
|
|
595
|
+
const b = rb(input, context);
|
|
926
596
|
const headers = {
|
|
927
597
|
"content-type": "application/json",
|
|
928
598
|
};
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
599
|
+
b.bp("/domains/{DomainName}/profiles/objects/merge");
|
|
600
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
932
601
|
let body;
|
|
933
602
|
body = JSON.stringify(take(input, {
|
|
934
603
|
FieldSourceProfileIds: (_) => _json(_),
|
|
935
604
|
MainProfileId: [],
|
|
936
605
|
ProfileIdsToBeMerged: (_) => _json(_),
|
|
937
606
|
}));
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
hostname,
|
|
941
|
-
port,
|
|
942
|
-
method: "POST",
|
|
943
|
-
headers,
|
|
944
|
-
path: resolvedPath,
|
|
945
|
-
body,
|
|
946
|
-
});
|
|
607
|
+
b.m("POST").h(headers).b(body);
|
|
608
|
+
return b.build();
|
|
947
609
|
};
|
|
948
610
|
export const se_PutIntegrationCommand = async (input, context) => {
|
|
949
|
-
const
|
|
611
|
+
const b = rb(input, context);
|
|
950
612
|
const headers = {
|
|
951
613
|
"content-type": "application/json",
|
|
952
614
|
};
|
|
953
|
-
|
|
954
|
-
|
|
615
|
+
b.bp("/domains/{DomainName}/integrations");
|
|
616
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
955
617
|
let body;
|
|
956
618
|
body = JSON.stringify(take(input, {
|
|
957
619
|
FlowDefinition: (_) => se_FlowDefinition(_, context),
|
|
@@ -960,47 +622,32 @@ export const se_PutIntegrationCommand = async (input, context) => {
|
|
|
960
622
|
Tags: (_) => _json(_),
|
|
961
623
|
Uri: [],
|
|
962
624
|
}));
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
hostname,
|
|
966
|
-
port,
|
|
967
|
-
method: "PUT",
|
|
968
|
-
headers,
|
|
969
|
-
path: resolvedPath,
|
|
970
|
-
body,
|
|
971
|
-
});
|
|
625
|
+
b.m("PUT").h(headers).b(body);
|
|
626
|
+
return b.build();
|
|
972
627
|
};
|
|
973
628
|
export const se_PutProfileObjectCommand = async (input, context) => {
|
|
974
|
-
const
|
|
629
|
+
const b = rb(input, context);
|
|
975
630
|
const headers = {
|
|
976
631
|
"content-type": "application/json",
|
|
977
632
|
};
|
|
978
|
-
|
|
979
|
-
|
|
633
|
+
b.bp("/domains/{DomainName}/profiles/objects");
|
|
634
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
980
635
|
let body;
|
|
981
636
|
body = JSON.stringify(take(input, {
|
|
982
637
|
Object: [],
|
|
983
638
|
ObjectTypeName: [],
|
|
984
639
|
}));
|
|
985
|
-
|
|
986
|
-
|
|
987
|
-
hostname,
|
|
988
|
-
port,
|
|
989
|
-
method: "PUT",
|
|
990
|
-
headers,
|
|
991
|
-
path: resolvedPath,
|
|
992
|
-
body,
|
|
993
|
-
});
|
|
640
|
+
b.m("PUT").h(headers).b(body);
|
|
641
|
+
return b.build();
|
|
994
642
|
};
|
|
995
643
|
export const se_PutProfileObjectTypeCommand = async (input, context) => {
|
|
996
|
-
const
|
|
644
|
+
const b = rb(input, context);
|
|
997
645
|
const headers = {
|
|
998
646
|
"content-type": "application/json",
|
|
999
647
|
};
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ObjectTypeName", () => input.ObjectTypeName, "{ObjectTypeName}", false);
|
|
648
|
+
b.bp("/domains/{DomainName}/object-types/{ObjectTypeName}");
|
|
649
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
650
|
+
b.p("ObjectTypeName", () => input.ObjectTypeName, "{ObjectTypeName}", false);
|
|
1004
651
|
let body;
|
|
1005
652
|
body = JSON.stringify(take(input, {
|
|
1006
653
|
AllowProfileCreation: [],
|
|
@@ -1013,26 +660,19 @@ export const se_PutProfileObjectTypeCommand = async (input, context) => {
|
|
|
1013
660
|
Tags: (_) => _json(_),
|
|
1014
661
|
TemplateId: [],
|
|
1015
662
|
}));
|
|
1016
|
-
|
|
1017
|
-
|
|
1018
|
-
hostname,
|
|
1019
|
-
port,
|
|
1020
|
-
method: "PUT",
|
|
1021
|
-
headers,
|
|
1022
|
-
path: resolvedPath,
|
|
1023
|
-
body,
|
|
1024
|
-
});
|
|
663
|
+
b.m("PUT").h(headers).b(body);
|
|
664
|
+
return b.build();
|
|
1025
665
|
};
|
|
1026
666
|
export const se_SearchProfilesCommand = async (input, context) => {
|
|
1027
|
-
const
|
|
667
|
+
const b = rb(input, context);
|
|
1028
668
|
const headers = {
|
|
1029
669
|
"content-type": "application/json",
|
|
1030
670
|
};
|
|
1031
|
-
|
|
1032
|
-
|
|
671
|
+
b.bp("/domains/{DomainName}/profiles/search");
|
|
672
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1033
673
|
const query = map({
|
|
1034
|
-
|
|
1035
|
-
|
|
674
|
+
[_nt]: [, input[_NT]],
|
|
675
|
+
[_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
|
|
1036
676
|
});
|
|
1037
677
|
let body;
|
|
1038
678
|
body = JSON.stringify(take(input, {
|
|
@@ -1041,93 +681,62 @@ export const se_SearchProfilesCommand = async (input, context) => {
|
|
|
1041
681
|
LogicalOperator: [],
|
|
1042
682
|
Values: (_) => _json(_),
|
|
1043
683
|
}));
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
hostname,
|
|
1047
|
-
port,
|
|
1048
|
-
method: "POST",
|
|
1049
|
-
headers,
|
|
1050
|
-
path: resolvedPath,
|
|
1051
|
-
query,
|
|
1052
|
-
body,
|
|
1053
|
-
});
|
|
684
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
685
|
+
return b.build();
|
|
1054
686
|
};
|
|
1055
687
|
export const se_TagResourceCommand = async (input, context) => {
|
|
1056
|
-
const
|
|
688
|
+
const b = rb(input, context);
|
|
1057
689
|
const headers = {
|
|
1058
690
|
"content-type": "application/json",
|
|
1059
691
|
};
|
|
1060
|
-
|
|
1061
|
-
|
|
692
|
+
b.bp("/tags/{resourceArn}");
|
|
693
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
1062
694
|
let body;
|
|
1063
695
|
body = JSON.stringify(take(input, {
|
|
1064
696
|
tags: (_) => _json(_),
|
|
1065
697
|
}));
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
hostname,
|
|
1069
|
-
port,
|
|
1070
|
-
method: "POST",
|
|
1071
|
-
headers,
|
|
1072
|
-
path: resolvedPath,
|
|
1073
|
-
body,
|
|
1074
|
-
});
|
|
698
|
+
b.m("POST").h(headers).b(body);
|
|
699
|
+
return b.build();
|
|
1075
700
|
};
|
|
1076
701
|
export const se_UntagResourceCommand = async (input, context) => {
|
|
1077
|
-
const
|
|
702
|
+
const b = rb(input, context);
|
|
1078
703
|
const headers = {};
|
|
1079
|
-
|
|
1080
|
-
|
|
704
|
+
b.bp("/tags/{resourceArn}");
|
|
705
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
1081
706
|
const query = map({
|
|
1082
|
-
|
|
707
|
+
[_tK]: [
|
|
1083
708
|
__expectNonNull(input.tagKeys, `tagKeys`) != null,
|
|
1084
|
-
() => (input
|
|
709
|
+
() => (input[_tK] || []).map((_entry) => _entry),
|
|
1085
710
|
],
|
|
1086
711
|
});
|
|
1087
712
|
let body;
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
hostname,
|
|
1091
|
-
port,
|
|
1092
|
-
method: "DELETE",
|
|
1093
|
-
headers,
|
|
1094
|
-
path: resolvedPath,
|
|
1095
|
-
query,
|
|
1096
|
-
body,
|
|
1097
|
-
});
|
|
713
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
714
|
+
return b.build();
|
|
1098
715
|
};
|
|
1099
716
|
export const se_UpdateCalculatedAttributeDefinitionCommand = async (input, context) => {
|
|
1100
|
-
const
|
|
717
|
+
const b = rb(input, context);
|
|
1101
718
|
const headers = {
|
|
1102
719
|
"content-type": "application/json",
|
|
1103
720
|
};
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
1107
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
721
|
+
b.bp("/domains/{DomainName}/calculated-attributes/{CalculatedAttributeName}");
|
|
722
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
723
|
+
b.p("CalculatedAttributeName", () => input.CalculatedAttributeName, "{CalculatedAttributeName}", false);
|
|
1108
724
|
let body;
|
|
1109
725
|
body = JSON.stringify(take(input, {
|
|
1110
726
|
Conditions: (_) => _json(_),
|
|
1111
727
|
Description: [],
|
|
1112
728
|
DisplayName: [],
|
|
1113
729
|
}));
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
hostname,
|
|
1117
|
-
port,
|
|
1118
|
-
method: "PUT",
|
|
1119
|
-
headers,
|
|
1120
|
-
path: resolvedPath,
|
|
1121
|
-
body,
|
|
1122
|
-
});
|
|
730
|
+
b.m("PUT").h(headers).b(body);
|
|
731
|
+
return b.build();
|
|
1123
732
|
};
|
|
1124
733
|
export const se_UpdateDomainCommand = async (input, context) => {
|
|
1125
|
-
const
|
|
734
|
+
const b = rb(input, context);
|
|
1126
735
|
const headers = {
|
|
1127
736
|
"content-type": "application/json",
|
|
1128
737
|
};
|
|
1129
|
-
|
|
1130
|
-
|
|
738
|
+
b.bp("/domains/{DomainName}");
|
|
739
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1131
740
|
let body;
|
|
1132
741
|
body = JSON.stringify(take(input, {
|
|
1133
742
|
DeadLetterQueueUrl: [],
|
|
@@ -1137,23 +746,16 @@ export const se_UpdateDomainCommand = async (input, context) => {
|
|
|
1137
746
|
RuleBasedMatching: (_) => _json(_),
|
|
1138
747
|
Tags: (_) => _json(_),
|
|
1139
748
|
}));
|
|
1140
|
-
|
|
1141
|
-
|
|
1142
|
-
hostname,
|
|
1143
|
-
port,
|
|
1144
|
-
method: "PUT",
|
|
1145
|
-
headers,
|
|
1146
|
-
path: resolvedPath,
|
|
1147
|
-
body,
|
|
1148
|
-
});
|
|
749
|
+
b.m("PUT").h(headers).b(body);
|
|
750
|
+
return b.build();
|
|
1149
751
|
};
|
|
1150
752
|
export const se_UpdateProfileCommand = async (input, context) => {
|
|
1151
|
-
const
|
|
753
|
+
const b = rb(input, context);
|
|
1152
754
|
const headers = {
|
|
1153
755
|
"content-type": "application/json",
|
|
1154
756
|
};
|
|
1155
|
-
|
|
1156
|
-
|
|
757
|
+
b.bp("/domains/{DomainName}/profiles");
|
|
758
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1157
759
|
let body;
|
|
1158
760
|
body = JSON.stringify(take(input, {
|
|
1159
761
|
AccountNumber: [],
|
|
@@ -1181,15 +783,8 @@ export const se_UpdateProfileCommand = async (input, context) => {
|
|
|
1181
783
|
ProfileId: [],
|
|
1182
784
|
ShippingAddress: (_) => _json(_),
|
|
1183
785
|
}));
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
hostname,
|
|
1187
|
-
port,
|
|
1188
|
-
method: "PUT",
|
|
1189
|
-
headers,
|
|
1190
|
-
path: resolvedPath,
|
|
1191
|
-
body,
|
|
1192
|
-
});
|
|
786
|
+
b.m("PUT").h(headers).b(body);
|
|
787
|
+
return b.build();
|
|
1193
788
|
};
|
|
1194
789
|
export const de_AddProfileKeyCommand = async (output, context) => {
|
|
1195
790
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3989,6 +3584,13 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
|
|
|
3989
3584
|
value !== "" &&
|
|
3990
3585
|
(!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
|
|
3991
3586
|
(!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
|
|
3587
|
+
const _IH = "IncludeHidden";
|
|
3588
|
+
const _MR = "MaxResults";
|
|
3589
|
+
const _NT = "NextToken";
|
|
3590
|
+
const _ih = "include-hidden";
|
|
3591
|
+
const _mr = "max-results";
|
|
3592
|
+
const _nt = "next-token";
|
|
3593
|
+
const _tK = "tagKeys";
|
|
3992
3594
|
const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
|
|
3993
3595
|
if (encoded.length) {
|
|
3994
3596
|
return JSON.parse(encoded);
|