@aws-sdk/client-vpc-lattice 3.474.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 +300 -693
- package/dist-es/protocols/Aws_restJson1.js +301 -694
- package/package.json +5 -4
|
@@ -1,38 +1,30 @@
|
|
|
1
1
|
import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
|
|
2
|
-
import {
|
|
3
|
-
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset,
|
|
2
|
+
import { requestBuilder as rb } from "@smithy/core";
|
|
3
|
+
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
|
|
4
4
|
import { v4 as generateIdempotencyToken } from "uuid";
|
|
5
5
|
import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
|
|
6
6
|
import { VPCLatticeServiceException as __BaseException } from "../models/VPCLatticeServiceException";
|
|
7
7
|
export const se_BatchUpdateRuleCommand = async (input, context) => {
|
|
8
|
-
const
|
|
8
|
+
const b = rb(input, context);
|
|
9
9
|
const headers = {
|
|
10
10
|
"content-type": "application/json",
|
|
11
11
|
};
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
12
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules");
|
|
13
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
14
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
16
15
|
let body;
|
|
17
16
|
body = JSON.stringify(take(input, {
|
|
18
17
|
rules: (_) => _json(_),
|
|
19
18
|
}));
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
hostname,
|
|
23
|
-
port,
|
|
24
|
-
method: "PATCH",
|
|
25
|
-
headers,
|
|
26
|
-
path: resolvedPath,
|
|
27
|
-
body,
|
|
28
|
-
});
|
|
19
|
+
b.m("PATCH").h(headers).b(body);
|
|
20
|
+
return b.build();
|
|
29
21
|
};
|
|
30
22
|
export const se_CreateAccessLogSubscriptionCommand = async (input, context) => {
|
|
31
|
-
const
|
|
23
|
+
const b = rb(input, context);
|
|
32
24
|
const headers = {
|
|
33
25
|
"content-type": "application/json",
|
|
34
26
|
};
|
|
35
|
-
|
|
27
|
+
b.bp("/accesslogsubscriptions");
|
|
36
28
|
let body;
|
|
37
29
|
body = JSON.stringify(take(input, {
|
|
38
30
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -40,23 +32,16 @@ export const se_CreateAccessLogSubscriptionCommand = async (input, context) => {
|
|
|
40
32
|
resourceIdentifier: [],
|
|
41
33
|
tags: (_) => _json(_),
|
|
42
34
|
}));
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
hostname,
|
|
46
|
-
port,
|
|
47
|
-
method: "POST",
|
|
48
|
-
headers,
|
|
49
|
-
path: resolvedPath,
|
|
50
|
-
body,
|
|
51
|
-
});
|
|
35
|
+
b.m("POST").h(headers).b(body);
|
|
36
|
+
return b.build();
|
|
52
37
|
};
|
|
53
38
|
export const se_CreateListenerCommand = async (input, context) => {
|
|
54
|
-
const
|
|
39
|
+
const b = rb(input, context);
|
|
55
40
|
const headers = {
|
|
56
41
|
"content-type": "application/json",
|
|
57
42
|
};
|
|
58
|
-
|
|
59
|
-
|
|
43
|
+
b.bp("/services/{serviceIdentifier}/listeners");
|
|
44
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
60
45
|
let body;
|
|
61
46
|
body = JSON.stringify(take(input, {
|
|
62
47
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -66,25 +51,17 @@ export const se_CreateListenerCommand = async (input, context) => {
|
|
|
66
51
|
protocol: [],
|
|
67
52
|
tags: (_) => _json(_),
|
|
68
53
|
}));
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
hostname,
|
|
72
|
-
port,
|
|
73
|
-
method: "POST",
|
|
74
|
-
headers,
|
|
75
|
-
path: resolvedPath,
|
|
76
|
-
body,
|
|
77
|
-
});
|
|
54
|
+
b.m("POST").h(headers).b(body);
|
|
55
|
+
return b.build();
|
|
78
56
|
};
|
|
79
57
|
export const se_CreateRuleCommand = async (input, context) => {
|
|
80
|
-
const
|
|
58
|
+
const b = rb(input, context);
|
|
81
59
|
const headers = {
|
|
82
60
|
"content-type": "application/json",
|
|
83
61
|
};
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
62
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules");
|
|
63
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
64
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
88
65
|
let body;
|
|
89
66
|
body = JSON.stringify(take(input, {
|
|
90
67
|
action: (_) => _json(_),
|
|
@@ -94,22 +71,15 @@ export const se_CreateRuleCommand = async (input, context) => {
|
|
|
94
71
|
priority: [],
|
|
95
72
|
tags: (_) => _json(_),
|
|
96
73
|
}));
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
hostname,
|
|
100
|
-
port,
|
|
101
|
-
method: "POST",
|
|
102
|
-
headers,
|
|
103
|
-
path: resolvedPath,
|
|
104
|
-
body,
|
|
105
|
-
});
|
|
74
|
+
b.m("POST").h(headers).b(body);
|
|
75
|
+
return b.build();
|
|
106
76
|
};
|
|
107
77
|
export const se_CreateServiceCommand = async (input, context) => {
|
|
108
|
-
const
|
|
78
|
+
const b = rb(input, context);
|
|
109
79
|
const headers = {
|
|
110
80
|
"content-type": "application/json",
|
|
111
81
|
};
|
|
112
|
-
|
|
82
|
+
b.bp("/services");
|
|
113
83
|
let body;
|
|
114
84
|
body = JSON.stringify(take(input, {
|
|
115
85
|
authType: [],
|
|
@@ -119,22 +89,15 @@ export const se_CreateServiceCommand = async (input, context) => {
|
|
|
119
89
|
name: [],
|
|
120
90
|
tags: (_) => _json(_),
|
|
121
91
|
}));
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
hostname,
|
|
125
|
-
port,
|
|
126
|
-
method: "POST",
|
|
127
|
-
headers,
|
|
128
|
-
path: resolvedPath,
|
|
129
|
-
body,
|
|
130
|
-
});
|
|
92
|
+
b.m("POST").h(headers).b(body);
|
|
93
|
+
return b.build();
|
|
131
94
|
};
|
|
132
95
|
export const se_CreateServiceNetworkCommand = async (input, context) => {
|
|
133
|
-
const
|
|
96
|
+
const b = rb(input, context);
|
|
134
97
|
const headers = {
|
|
135
98
|
"content-type": "application/json",
|
|
136
99
|
};
|
|
137
|
-
|
|
100
|
+
b.bp("/servicenetworks");
|
|
138
101
|
let body;
|
|
139
102
|
body = JSON.stringify(take(input, {
|
|
140
103
|
authType: [],
|
|
@@ -142,22 +105,15 @@ export const se_CreateServiceNetworkCommand = async (input, context) => {
|
|
|
142
105
|
name: [],
|
|
143
106
|
tags: (_) => _json(_),
|
|
144
107
|
}));
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
hostname,
|
|
148
|
-
port,
|
|
149
|
-
method: "POST",
|
|
150
|
-
headers,
|
|
151
|
-
path: resolvedPath,
|
|
152
|
-
body,
|
|
153
|
-
});
|
|
108
|
+
b.m("POST").h(headers).b(body);
|
|
109
|
+
return b.build();
|
|
154
110
|
};
|
|
155
111
|
export const se_CreateServiceNetworkServiceAssociationCommand = async (input, context) => {
|
|
156
|
-
const
|
|
112
|
+
const b = rb(input, context);
|
|
157
113
|
const headers = {
|
|
158
114
|
"content-type": "application/json",
|
|
159
115
|
};
|
|
160
|
-
|
|
116
|
+
b.bp("/servicenetworkserviceassociations");
|
|
161
117
|
let body;
|
|
162
118
|
body = JSON.stringify(take(input, {
|
|
163
119
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -165,22 +121,15 @@ export const se_CreateServiceNetworkServiceAssociationCommand = async (input, co
|
|
|
165
121
|
serviceNetworkIdentifier: [],
|
|
166
122
|
tags: (_) => _json(_),
|
|
167
123
|
}));
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
hostname,
|
|
171
|
-
port,
|
|
172
|
-
method: "POST",
|
|
173
|
-
headers,
|
|
174
|
-
path: resolvedPath,
|
|
175
|
-
body,
|
|
176
|
-
});
|
|
124
|
+
b.m("POST").h(headers).b(body);
|
|
125
|
+
return b.build();
|
|
177
126
|
};
|
|
178
127
|
export const se_CreateServiceNetworkVpcAssociationCommand = async (input, context) => {
|
|
179
|
-
const
|
|
128
|
+
const b = rb(input, context);
|
|
180
129
|
const headers = {
|
|
181
130
|
"content-type": "application/json",
|
|
182
131
|
};
|
|
183
|
-
|
|
132
|
+
b.bp("/servicenetworkvpcassociations");
|
|
184
133
|
let body;
|
|
185
134
|
body = JSON.stringify(take(input, {
|
|
186
135
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -189,22 +138,15 @@ export const se_CreateServiceNetworkVpcAssociationCommand = async (input, contex
|
|
|
189
138
|
tags: (_) => _json(_),
|
|
190
139
|
vpcIdentifier: [],
|
|
191
140
|
}));
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
hostname,
|
|
195
|
-
port,
|
|
196
|
-
method: "POST",
|
|
197
|
-
headers,
|
|
198
|
-
path: resolvedPath,
|
|
199
|
-
body,
|
|
200
|
-
});
|
|
141
|
+
b.m("POST").h(headers).b(body);
|
|
142
|
+
return b.build();
|
|
201
143
|
};
|
|
202
144
|
export const se_CreateTargetGroupCommand = async (input, context) => {
|
|
203
|
-
const
|
|
145
|
+
const b = rb(input, context);
|
|
204
146
|
const headers = {
|
|
205
147
|
"content-type": "application/json",
|
|
206
148
|
};
|
|
207
|
-
|
|
149
|
+
b.bp("/targetgroups");
|
|
208
150
|
let body;
|
|
209
151
|
body = JSON.stringify(take(input, {
|
|
210
152
|
clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
|
|
@@ -213,855 +155,516 @@ export const se_CreateTargetGroupCommand = async (input, context) => {
|
|
|
213
155
|
tags: (_) => _json(_),
|
|
214
156
|
type: [],
|
|
215
157
|
}));
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
hostname,
|
|
219
|
-
port,
|
|
220
|
-
method: "POST",
|
|
221
|
-
headers,
|
|
222
|
-
path: resolvedPath,
|
|
223
|
-
body,
|
|
224
|
-
});
|
|
158
|
+
b.m("POST").h(headers).b(body);
|
|
159
|
+
return b.build();
|
|
225
160
|
};
|
|
226
161
|
export const se_DeleteAccessLogSubscriptionCommand = async (input, context) => {
|
|
227
|
-
const
|
|
162
|
+
const b = rb(input, context);
|
|
228
163
|
const headers = {};
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
|
|
164
|
+
b.bp("/accesslogsubscriptions/{accessLogSubscriptionIdentifier}");
|
|
165
|
+
b.p("accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
|
|
232
166
|
let body;
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
hostname,
|
|
236
|
-
port,
|
|
237
|
-
method: "DELETE",
|
|
238
|
-
headers,
|
|
239
|
-
path: resolvedPath,
|
|
240
|
-
body,
|
|
241
|
-
});
|
|
167
|
+
b.m("DELETE").h(headers).b(body);
|
|
168
|
+
return b.build();
|
|
242
169
|
};
|
|
243
170
|
export const se_DeleteAuthPolicyCommand = async (input, context) => {
|
|
244
|
-
const
|
|
171
|
+
const b = rb(input, context);
|
|
245
172
|
const headers = {};
|
|
246
|
-
|
|
247
|
-
|
|
173
|
+
b.bp("/authpolicy/{resourceIdentifier}");
|
|
174
|
+
b.p("resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
|
|
248
175
|
let body;
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
hostname,
|
|
252
|
-
port,
|
|
253
|
-
method: "DELETE",
|
|
254
|
-
headers,
|
|
255
|
-
path: resolvedPath,
|
|
256
|
-
body,
|
|
257
|
-
});
|
|
176
|
+
b.m("DELETE").h(headers).b(body);
|
|
177
|
+
return b.build();
|
|
258
178
|
};
|
|
259
179
|
export const se_DeleteListenerCommand = async (input, context) => {
|
|
260
|
-
const
|
|
180
|
+
const b = rb(input, context);
|
|
261
181
|
const headers = {};
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
182
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}");
|
|
183
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
184
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
266
185
|
let body;
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
hostname,
|
|
270
|
-
port,
|
|
271
|
-
method: "DELETE",
|
|
272
|
-
headers,
|
|
273
|
-
path: resolvedPath,
|
|
274
|
-
body,
|
|
275
|
-
});
|
|
186
|
+
b.m("DELETE").h(headers).b(body);
|
|
187
|
+
return b.build();
|
|
276
188
|
};
|
|
277
189
|
export const se_DeleteResourcePolicyCommand = async (input, context) => {
|
|
278
|
-
const
|
|
190
|
+
const b = rb(input, context);
|
|
279
191
|
const headers = {};
|
|
280
|
-
|
|
281
|
-
|
|
192
|
+
b.bp("/resourcepolicy/{resourceArn}");
|
|
193
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
282
194
|
let body;
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
hostname,
|
|
286
|
-
port,
|
|
287
|
-
method: "DELETE",
|
|
288
|
-
headers,
|
|
289
|
-
path: resolvedPath,
|
|
290
|
-
body,
|
|
291
|
-
});
|
|
195
|
+
b.m("DELETE").h(headers).b(body);
|
|
196
|
+
return b.build();
|
|
292
197
|
};
|
|
293
198
|
export const se_DeleteRuleCommand = async (input, context) => {
|
|
294
|
-
const
|
|
199
|
+
const b = rb(input, context);
|
|
295
200
|
const headers = {};
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
|
|
201
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}");
|
|
202
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
203
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
204
|
+
b.p("ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
|
|
301
205
|
let body;
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
hostname,
|
|
305
|
-
port,
|
|
306
|
-
method: "DELETE",
|
|
307
|
-
headers,
|
|
308
|
-
path: resolvedPath,
|
|
309
|
-
body,
|
|
310
|
-
});
|
|
206
|
+
b.m("DELETE").h(headers).b(body);
|
|
207
|
+
return b.build();
|
|
311
208
|
};
|
|
312
209
|
export const se_DeleteServiceCommand = async (input, context) => {
|
|
313
|
-
const
|
|
210
|
+
const b = rb(input, context);
|
|
314
211
|
const headers = {};
|
|
315
|
-
|
|
316
|
-
|
|
212
|
+
b.bp("/services/{serviceIdentifier}");
|
|
213
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
317
214
|
let body;
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
hostname,
|
|
321
|
-
port,
|
|
322
|
-
method: "DELETE",
|
|
323
|
-
headers,
|
|
324
|
-
path: resolvedPath,
|
|
325
|
-
body,
|
|
326
|
-
});
|
|
215
|
+
b.m("DELETE").h(headers).b(body);
|
|
216
|
+
return b.build();
|
|
327
217
|
};
|
|
328
218
|
export const se_DeleteServiceNetworkCommand = async (input, context) => {
|
|
329
|
-
const
|
|
219
|
+
const b = rb(input, context);
|
|
330
220
|
const headers = {};
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
|
|
221
|
+
b.bp("/servicenetworks/{serviceNetworkIdentifier}");
|
|
222
|
+
b.p("serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
|
|
334
223
|
let body;
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
hostname,
|
|
338
|
-
port,
|
|
339
|
-
method: "DELETE",
|
|
340
|
-
headers,
|
|
341
|
-
path: resolvedPath,
|
|
342
|
-
body,
|
|
343
|
-
});
|
|
224
|
+
b.m("DELETE").h(headers).b(body);
|
|
225
|
+
return b.build();
|
|
344
226
|
};
|
|
345
227
|
export const se_DeleteServiceNetworkServiceAssociationCommand = async (input, context) => {
|
|
346
|
-
const
|
|
228
|
+
const b = rb(input, context);
|
|
347
229
|
const headers = {};
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
|
|
230
|
+
b.bp("/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}");
|
|
231
|
+
b.p("serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
|
|
351
232
|
let body;
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
hostname,
|
|
355
|
-
port,
|
|
356
|
-
method: "DELETE",
|
|
357
|
-
headers,
|
|
358
|
-
path: resolvedPath,
|
|
359
|
-
body,
|
|
360
|
-
});
|
|
233
|
+
b.m("DELETE").h(headers).b(body);
|
|
234
|
+
return b.build();
|
|
361
235
|
};
|
|
362
236
|
export const se_DeleteServiceNetworkVpcAssociationCommand = async (input, context) => {
|
|
363
|
-
const
|
|
237
|
+
const b = rb(input, context);
|
|
364
238
|
const headers = {};
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
|
|
239
|
+
b.bp("/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}");
|
|
240
|
+
b.p("serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
|
|
368
241
|
let body;
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
hostname,
|
|
372
|
-
port,
|
|
373
|
-
method: "DELETE",
|
|
374
|
-
headers,
|
|
375
|
-
path: resolvedPath,
|
|
376
|
-
body,
|
|
377
|
-
});
|
|
242
|
+
b.m("DELETE").h(headers).b(body);
|
|
243
|
+
return b.build();
|
|
378
244
|
};
|
|
379
245
|
export const se_DeleteTargetGroupCommand = async (input, context) => {
|
|
380
|
-
const
|
|
246
|
+
const b = rb(input, context);
|
|
381
247
|
const headers = {};
|
|
382
|
-
|
|
383
|
-
|
|
248
|
+
b.bp("/targetgroups/{targetGroupIdentifier}");
|
|
249
|
+
b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
384
250
|
let body;
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
hostname,
|
|
388
|
-
port,
|
|
389
|
-
method: "DELETE",
|
|
390
|
-
headers,
|
|
391
|
-
path: resolvedPath,
|
|
392
|
-
body,
|
|
393
|
-
});
|
|
251
|
+
b.m("DELETE").h(headers).b(body);
|
|
252
|
+
return b.build();
|
|
394
253
|
};
|
|
395
254
|
export const se_DeregisterTargetsCommand = async (input, context) => {
|
|
396
|
-
const
|
|
255
|
+
const b = rb(input, context);
|
|
397
256
|
const headers = {
|
|
398
257
|
"content-type": "application/json",
|
|
399
258
|
};
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
259
|
+
b.bp("/targetgroups/{targetGroupIdentifier}/deregistertargets");
|
|
260
|
+
b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
403
261
|
let body;
|
|
404
262
|
body = JSON.stringify(take(input, {
|
|
405
263
|
targets: (_) => _json(_),
|
|
406
264
|
}));
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
hostname,
|
|
410
|
-
port,
|
|
411
|
-
method: "POST",
|
|
412
|
-
headers,
|
|
413
|
-
path: resolvedPath,
|
|
414
|
-
body,
|
|
415
|
-
});
|
|
265
|
+
b.m("POST").h(headers).b(body);
|
|
266
|
+
return b.build();
|
|
416
267
|
};
|
|
417
268
|
export const se_GetAccessLogSubscriptionCommand = async (input, context) => {
|
|
418
|
-
const
|
|
269
|
+
const b = rb(input, context);
|
|
419
270
|
const headers = {};
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
|
|
271
|
+
b.bp("/accesslogsubscriptions/{accessLogSubscriptionIdentifier}");
|
|
272
|
+
b.p("accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
|
|
423
273
|
let body;
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
hostname,
|
|
427
|
-
port,
|
|
428
|
-
method: "GET",
|
|
429
|
-
headers,
|
|
430
|
-
path: resolvedPath,
|
|
431
|
-
body,
|
|
432
|
-
});
|
|
274
|
+
b.m("GET").h(headers).b(body);
|
|
275
|
+
return b.build();
|
|
433
276
|
};
|
|
434
277
|
export const se_GetAuthPolicyCommand = async (input, context) => {
|
|
435
|
-
const
|
|
278
|
+
const b = rb(input, context);
|
|
436
279
|
const headers = {};
|
|
437
|
-
|
|
438
|
-
|
|
280
|
+
b.bp("/authpolicy/{resourceIdentifier}");
|
|
281
|
+
b.p("resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
|
|
439
282
|
let body;
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
hostname,
|
|
443
|
-
port,
|
|
444
|
-
method: "GET",
|
|
445
|
-
headers,
|
|
446
|
-
path: resolvedPath,
|
|
447
|
-
body,
|
|
448
|
-
});
|
|
283
|
+
b.m("GET").h(headers).b(body);
|
|
284
|
+
return b.build();
|
|
449
285
|
};
|
|
450
286
|
export const se_GetListenerCommand = async (input, context) => {
|
|
451
|
-
const
|
|
287
|
+
const b = rb(input, context);
|
|
452
288
|
const headers = {};
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
289
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}");
|
|
290
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
291
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
457
292
|
let body;
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
hostname,
|
|
461
|
-
port,
|
|
462
|
-
method: "GET",
|
|
463
|
-
headers,
|
|
464
|
-
path: resolvedPath,
|
|
465
|
-
body,
|
|
466
|
-
});
|
|
293
|
+
b.m("GET").h(headers).b(body);
|
|
294
|
+
return b.build();
|
|
467
295
|
};
|
|
468
296
|
export const se_GetResourcePolicyCommand = async (input, context) => {
|
|
469
|
-
const
|
|
297
|
+
const b = rb(input, context);
|
|
470
298
|
const headers = {};
|
|
471
|
-
|
|
472
|
-
|
|
299
|
+
b.bp("/resourcepolicy/{resourceArn}");
|
|
300
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
473
301
|
let body;
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
hostname,
|
|
477
|
-
port,
|
|
478
|
-
method: "GET",
|
|
479
|
-
headers,
|
|
480
|
-
path: resolvedPath,
|
|
481
|
-
body,
|
|
482
|
-
});
|
|
302
|
+
b.m("GET").h(headers).b(body);
|
|
303
|
+
return b.build();
|
|
483
304
|
};
|
|
484
305
|
export const se_GetRuleCommand = async (input, context) => {
|
|
485
|
-
const
|
|
306
|
+
const b = rb(input, context);
|
|
486
307
|
const headers = {};
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
|
|
308
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}");
|
|
309
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
310
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
311
|
+
b.p("ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
|
|
492
312
|
let body;
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
hostname,
|
|
496
|
-
port,
|
|
497
|
-
method: "GET",
|
|
498
|
-
headers,
|
|
499
|
-
path: resolvedPath,
|
|
500
|
-
body,
|
|
501
|
-
});
|
|
313
|
+
b.m("GET").h(headers).b(body);
|
|
314
|
+
return b.build();
|
|
502
315
|
};
|
|
503
316
|
export const se_GetServiceCommand = async (input, context) => {
|
|
504
|
-
const
|
|
317
|
+
const b = rb(input, context);
|
|
505
318
|
const headers = {};
|
|
506
|
-
|
|
507
|
-
|
|
319
|
+
b.bp("/services/{serviceIdentifier}");
|
|
320
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
508
321
|
let body;
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
hostname,
|
|
512
|
-
port,
|
|
513
|
-
method: "GET",
|
|
514
|
-
headers,
|
|
515
|
-
path: resolvedPath,
|
|
516
|
-
body,
|
|
517
|
-
});
|
|
322
|
+
b.m("GET").h(headers).b(body);
|
|
323
|
+
return b.build();
|
|
518
324
|
};
|
|
519
325
|
export const se_GetServiceNetworkCommand = async (input, context) => {
|
|
520
|
-
const
|
|
326
|
+
const b = rb(input, context);
|
|
521
327
|
const headers = {};
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
|
|
328
|
+
b.bp("/servicenetworks/{serviceNetworkIdentifier}");
|
|
329
|
+
b.p("serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
|
|
525
330
|
let body;
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
hostname,
|
|
529
|
-
port,
|
|
530
|
-
method: "GET",
|
|
531
|
-
headers,
|
|
532
|
-
path: resolvedPath,
|
|
533
|
-
body,
|
|
534
|
-
});
|
|
331
|
+
b.m("GET").h(headers).b(body);
|
|
332
|
+
return b.build();
|
|
535
333
|
};
|
|
536
334
|
export const se_GetServiceNetworkServiceAssociationCommand = async (input, context) => {
|
|
537
|
-
const
|
|
335
|
+
const b = rb(input, context);
|
|
538
336
|
const headers = {};
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
|
|
337
|
+
b.bp("/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}");
|
|
338
|
+
b.p("serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
|
|
542
339
|
let body;
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
hostname,
|
|
546
|
-
port,
|
|
547
|
-
method: "GET",
|
|
548
|
-
headers,
|
|
549
|
-
path: resolvedPath,
|
|
550
|
-
body,
|
|
551
|
-
});
|
|
340
|
+
b.m("GET").h(headers).b(body);
|
|
341
|
+
return b.build();
|
|
552
342
|
};
|
|
553
343
|
export const se_GetServiceNetworkVpcAssociationCommand = async (input, context) => {
|
|
554
|
-
const
|
|
344
|
+
const b = rb(input, context);
|
|
555
345
|
const headers = {};
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
|
|
346
|
+
b.bp("/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}");
|
|
347
|
+
b.p("serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
|
|
559
348
|
let body;
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
hostname,
|
|
563
|
-
port,
|
|
564
|
-
method: "GET",
|
|
565
|
-
headers,
|
|
566
|
-
path: resolvedPath,
|
|
567
|
-
body,
|
|
568
|
-
});
|
|
349
|
+
b.m("GET").h(headers).b(body);
|
|
350
|
+
return b.build();
|
|
569
351
|
};
|
|
570
352
|
export const se_GetTargetGroupCommand = async (input, context) => {
|
|
571
|
-
const
|
|
353
|
+
const b = rb(input, context);
|
|
572
354
|
const headers = {};
|
|
573
|
-
|
|
574
|
-
|
|
355
|
+
b.bp("/targetgroups/{targetGroupIdentifier}");
|
|
356
|
+
b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
575
357
|
let body;
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
hostname,
|
|
579
|
-
port,
|
|
580
|
-
method: "GET",
|
|
581
|
-
headers,
|
|
582
|
-
path: resolvedPath,
|
|
583
|
-
body,
|
|
584
|
-
});
|
|
358
|
+
b.m("GET").h(headers).b(body);
|
|
359
|
+
return b.build();
|
|
585
360
|
};
|
|
586
361
|
export const se_ListAccessLogSubscriptionsCommand = async (input, context) => {
|
|
587
|
-
const
|
|
362
|
+
const b = rb(input, context);
|
|
588
363
|
const headers = {};
|
|
589
|
-
|
|
364
|
+
b.bp("/accesslogsubscriptions");
|
|
590
365
|
const query = map({
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
366
|
+
[_rI]: [, __expectNonNull(input[_rI], `resourceIdentifier`)],
|
|
367
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
368
|
+
[_nT]: [, input[_nT]],
|
|
594
369
|
});
|
|
595
370
|
let body;
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
hostname,
|
|
599
|
-
port,
|
|
600
|
-
method: "GET",
|
|
601
|
-
headers,
|
|
602
|
-
path: resolvedPath,
|
|
603
|
-
query,
|
|
604
|
-
body,
|
|
605
|
-
});
|
|
371
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
372
|
+
return b.build();
|
|
606
373
|
};
|
|
607
374
|
export const se_ListListenersCommand = async (input, context) => {
|
|
608
|
-
const
|
|
375
|
+
const b = rb(input, context);
|
|
609
376
|
const headers = {};
|
|
610
|
-
|
|
611
|
-
|
|
377
|
+
b.bp("/services/{serviceIdentifier}/listeners");
|
|
378
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
612
379
|
const query = map({
|
|
613
|
-
|
|
614
|
-
|
|
380
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
381
|
+
[_nT]: [, input[_nT]],
|
|
615
382
|
});
|
|
616
383
|
let body;
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
hostname,
|
|
620
|
-
port,
|
|
621
|
-
method: "GET",
|
|
622
|
-
headers,
|
|
623
|
-
path: resolvedPath,
|
|
624
|
-
query,
|
|
625
|
-
body,
|
|
626
|
-
});
|
|
384
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
385
|
+
return b.build();
|
|
627
386
|
};
|
|
628
387
|
export const se_ListRulesCommand = async (input, context) => {
|
|
629
|
-
const
|
|
388
|
+
const b = rb(input, context);
|
|
630
389
|
const headers = {};
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
390
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules");
|
|
391
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
392
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
635
393
|
const query = map({
|
|
636
|
-
|
|
637
|
-
|
|
394
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
395
|
+
[_nT]: [, input[_nT]],
|
|
638
396
|
});
|
|
639
397
|
let body;
|
|
640
|
-
|
|
641
|
-
|
|
642
|
-
hostname,
|
|
643
|
-
port,
|
|
644
|
-
method: "GET",
|
|
645
|
-
headers,
|
|
646
|
-
path: resolvedPath,
|
|
647
|
-
query,
|
|
648
|
-
body,
|
|
649
|
-
});
|
|
398
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
399
|
+
return b.build();
|
|
650
400
|
};
|
|
651
401
|
export const se_ListServiceNetworksCommand = async (input, context) => {
|
|
652
|
-
const
|
|
402
|
+
const b = rb(input, context);
|
|
653
403
|
const headers = {};
|
|
654
|
-
|
|
404
|
+
b.bp("/servicenetworks");
|
|
655
405
|
const query = map({
|
|
656
|
-
|
|
657
|
-
|
|
406
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
407
|
+
[_nT]: [, input[_nT]],
|
|
658
408
|
});
|
|
659
409
|
let body;
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
hostname,
|
|
663
|
-
port,
|
|
664
|
-
method: "GET",
|
|
665
|
-
headers,
|
|
666
|
-
path: resolvedPath,
|
|
667
|
-
query,
|
|
668
|
-
body,
|
|
669
|
-
});
|
|
410
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
411
|
+
return b.build();
|
|
670
412
|
};
|
|
671
413
|
export const se_ListServiceNetworkServiceAssociationsCommand = async (input, context) => {
|
|
672
|
-
const
|
|
414
|
+
const b = rb(input, context);
|
|
673
415
|
const headers = {};
|
|
674
|
-
|
|
416
|
+
b.bp("/servicenetworkserviceassociations");
|
|
675
417
|
const query = map({
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
418
|
+
[_sNI]: [, input[_sNI]],
|
|
419
|
+
[_sI]: [, input[_sI]],
|
|
420
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
421
|
+
[_nT]: [, input[_nT]],
|
|
680
422
|
});
|
|
681
423
|
let body;
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
hostname,
|
|
685
|
-
port,
|
|
686
|
-
method: "GET",
|
|
687
|
-
headers,
|
|
688
|
-
path: resolvedPath,
|
|
689
|
-
query,
|
|
690
|
-
body,
|
|
691
|
-
});
|
|
424
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
425
|
+
return b.build();
|
|
692
426
|
};
|
|
693
427
|
export const se_ListServiceNetworkVpcAssociationsCommand = async (input, context) => {
|
|
694
|
-
const
|
|
428
|
+
const b = rb(input, context);
|
|
695
429
|
const headers = {};
|
|
696
|
-
|
|
430
|
+
b.bp("/servicenetworkvpcassociations");
|
|
697
431
|
const query = map({
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
432
|
+
[_sNI]: [, input[_sNI]],
|
|
433
|
+
[_vI]: [, input[_vI]],
|
|
434
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
435
|
+
[_nT]: [, input[_nT]],
|
|
702
436
|
});
|
|
703
437
|
let body;
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
hostname,
|
|
707
|
-
port,
|
|
708
|
-
method: "GET",
|
|
709
|
-
headers,
|
|
710
|
-
path: resolvedPath,
|
|
711
|
-
query,
|
|
712
|
-
body,
|
|
713
|
-
});
|
|
438
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
439
|
+
return b.build();
|
|
714
440
|
};
|
|
715
441
|
export const se_ListServicesCommand = async (input, context) => {
|
|
716
|
-
const
|
|
442
|
+
const b = rb(input, context);
|
|
717
443
|
const headers = {};
|
|
718
|
-
|
|
444
|
+
b.bp("/services");
|
|
719
445
|
const query = map({
|
|
720
|
-
|
|
721
|
-
|
|
446
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
447
|
+
[_nT]: [, input[_nT]],
|
|
722
448
|
});
|
|
723
449
|
let body;
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
hostname,
|
|
727
|
-
port,
|
|
728
|
-
method: "GET",
|
|
729
|
-
headers,
|
|
730
|
-
path: resolvedPath,
|
|
731
|
-
query,
|
|
732
|
-
body,
|
|
733
|
-
});
|
|
450
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
451
|
+
return b.build();
|
|
734
452
|
};
|
|
735
453
|
export const se_ListTagsForResourceCommand = async (input, context) => {
|
|
736
|
-
const
|
|
454
|
+
const b = rb(input, context);
|
|
737
455
|
const headers = {};
|
|
738
|
-
|
|
739
|
-
|
|
456
|
+
b.bp("/tags/{resourceArn}");
|
|
457
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
740
458
|
let body;
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
hostname,
|
|
744
|
-
port,
|
|
745
|
-
method: "GET",
|
|
746
|
-
headers,
|
|
747
|
-
path: resolvedPath,
|
|
748
|
-
body,
|
|
749
|
-
});
|
|
459
|
+
b.m("GET").h(headers).b(body);
|
|
460
|
+
return b.build();
|
|
750
461
|
};
|
|
751
462
|
export const se_ListTargetGroupsCommand = async (input, context) => {
|
|
752
|
-
const
|
|
463
|
+
const b = rb(input, context);
|
|
753
464
|
const headers = {};
|
|
754
|
-
|
|
465
|
+
b.bp("/targetgroups");
|
|
755
466
|
const query = map({
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
467
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
468
|
+
[_nT]: [, input[_nT]],
|
|
469
|
+
[_vI]: [, input[_vI]],
|
|
470
|
+
[_tGT]: [, input[_tGT]],
|
|
760
471
|
});
|
|
761
472
|
let body;
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
hostname,
|
|
765
|
-
port,
|
|
766
|
-
method: "GET",
|
|
767
|
-
headers,
|
|
768
|
-
path: resolvedPath,
|
|
769
|
-
query,
|
|
770
|
-
body,
|
|
771
|
-
});
|
|
473
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
474
|
+
return b.build();
|
|
772
475
|
};
|
|
773
476
|
export const se_ListTargetsCommand = async (input, context) => {
|
|
774
|
-
const
|
|
477
|
+
const b = rb(input, context);
|
|
775
478
|
const headers = {
|
|
776
479
|
"content-type": "application/json",
|
|
777
480
|
};
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
481
|
+
b.bp("/targetgroups/{targetGroupIdentifier}/listtargets");
|
|
482
|
+
b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
781
483
|
const query = map({
|
|
782
|
-
|
|
783
|
-
|
|
484
|
+
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
|
|
485
|
+
[_nT]: [, input[_nT]],
|
|
784
486
|
});
|
|
785
487
|
let body;
|
|
786
488
|
body = JSON.stringify(take(input, {
|
|
787
489
|
targets: (_) => _json(_),
|
|
788
490
|
}));
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
hostname,
|
|
792
|
-
port,
|
|
793
|
-
method: "POST",
|
|
794
|
-
headers,
|
|
795
|
-
path: resolvedPath,
|
|
796
|
-
query,
|
|
797
|
-
body,
|
|
798
|
-
});
|
|
491
|
+
b.m("POST").h(headers).q(query).b(body);
|
|
492
|
+
return b.build();
|
|
799
493
|
};
|
|
800
494
|
export const se_PutAuthPolicyCommand = async (input, context) => {
|
|
801
|
-
const
|
|
495
|
+
const b = rb(input, context);
|
|
802
496
|
const headers = {
|
|
803
497
|
"content-type": "application/json",
|
|
804
498
|
};
|
|
805
|
-
|
|
806
|
-
|
|
499
|
+
b.bp("/authpolicy/{resourceIdentifier}");
|
|
500
|
+
b.p("resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
|
|
807
501
|
let body;
|
|
808
502
|
body = JSON.stringify(take(input, {
|
|
809
503
|
policy: [],
|
|
810
504
|
}));
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
hostname,
|
|
814
|
-
port,
|
|
815
|
-
method: "PUT",
|
|
816
|
-
headers,
|
|
817
|
-
path: resolvedPath,
|
|
818
|
-
body,
|
|
819
|
-
});
|
|
505
|
+
b.m("PUT").h(headers).b(body);
|
|
506
|
+
return b.build();
|
|
820
507
|
};
|
|
821
508
|
export const se_PutResourcePolicyCommand = async (input, context) => {
|
|
822
|
-
const
|
|
509
|
+
const b = rb(input, context);
|
|
823
510
|
const headers = {
|
|
824
511
|
"content-type": "application/json",
|
|
825
512
|
};
|
|
826
|
-
|
|
827
|
-
|
|
513
|
+
b.bp("/resourcepolicy/{resourceArn}");
|
|
514
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
828
515
|
let body;
|
|
829
516
|
body = JSON.stringify(take(input, {
|
|
830
517
|
policy: [],
|
|
831
518
|
}));
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
hostname,
|
|
835
|
-
port,
|
|
836
|
-
method: "PUT",
|
|
837
|
-
headers,
|
|
838
|
-
path: resolvedPath,
|
|
839
|
-
body,
|
|
840
|
-
});
|
|
519
|
+
b.m("PUT").h(headers).b(body);
|
|
520
|
+
return b.build();
|
|
841
521
|
};
|
|
842
522
|
export const se_RegisterTargetsCommand = async (input, context) => {
|
|
843
|
-
const
|
|
523
|
+
const b = rb(input, context);
|
|
844
524
|
const headers = {
|
|
845
525
|
"content-type": "application/json",
|
|
846
526
|
};
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
527
|
+
b.bp("/targetgroups/{targetGroupIdentifier}/registertargets");
|
|
528
|
+
b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
850
529
|
let body;
|
|
851
530
|
body = JSON.stringify(take(input, {
|
|
852
531
|
targets: (_) => _json(_),
|
|
853
532
|
}));
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
hostname,
|
|
857
|
-
port,
|
|
858
|
-
method: "POST",
|
|
859
|
-
headers,
|
|
860
|
-
path: resolvedPath,
|
|
861
|
-
body,
|
|
862
|
-
});
|
|
533
|
+
b.m("POST").h(headers).b(body);
|
|
534
|
+
return b.build();
|
|
863
535
|
};
|
|
864
536
|
export const se_TagResourceCommand = async (input, context) => {
|
|
865
|
-
const
|
|
537
|
+
const b = rb(input, context);
|
|
866
538
|
const headers = {
|
|
867
539
|
"content-type": "application/json",
|
|
868
540
|
};
|
|
869
|
-
|
|
870
|
-
|
|
541
|
+
b.bp("/tags/{resourceArn}");
|
|
542
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
871
543
|
let body;
|
|
872
544
|
body = JSON.stringify(take(input, {
|
|
873
545
|
tags: (_) => _json(_),
|
|
874
546
|
}));
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
hostname,
|
|
878
|
-
port,
|
|
879
|
-
method: "POST",
|
|
880
|
-
headers,
|
|
881
|
-
path: resolvedPath,
|
|
882
|
-
body,
|
|
883
|
-
});
|
|
547
|
+
b.m("POST").h(headers).b(body);
|
|
548
|
+
return b.build();
|
|
884
549
|
};
|
|
885
550
|
export const se_UntagResourceCommand = async (input, context) => {
|
|
886
|
-
const
|
|
551
|
+
const b = rb(input, context);
|
|
887
552
|
const headers = {};
|
|
888
|
-
|
|
889
|
-
|
|
553
|
+
b.bp("/tags/{resourceArn}");
|
|
554
|
+
b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
|
|
890
555
|
const query = map({
|
|
891
|
-
|
|
556
|
+
[_tK]: [
|
|
892
557
|
__expectNonNull(input.tagKeys, `tagKeys`) != null,
|
|
893
|
-
() => (input
|
|
558
|
+
() => (input[_tK] || []).map((_entry) => _entry),
|
|
894
559
|
],
|
|
895
560
|
});
|
|
896
561
|
let body;
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
hostname,
|
|
900
|
-
port,
|
|
901
|
-
method: "DELETE",
|
|
902
|
-
headers,
|
|
903
|
-
path: resolvedPath,
|
|
904
|
-
query,
|
|
905
|
-
body,
|
|
906
|
-
});
|
|
562
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
563
|
+
return b.build();
|
|
907
564
|
};
|
|
908
565
|
export const se_UpdateAccessLogSubscriptionCommand = async (input, context) => {
|
|
909
|
-
const
|
|
566
|
+
const b = rb(input, context);
|
|
910
567
|
const headers = {
|
|
911
568
|
"content-type": "application/json",
|
|
912
569
|
};
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
|
|
570
|
+
b.bp("/accesslogsubscriptions/{accessLogSubscriptionIdentifier}");
|
|
571
|
+
b.p("accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
|
|
916
572
|
let body;
|
|
917
573
|
body = JSON.stringify(take(input, {
|
|
918
574
|
destinationArn: [],
|
|
919
575
|
}));
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
hostname,
|
|
923
|
-
port,
|
|
924
|
-
method: "PATCH",
|
|
925
|
-
headers,
|
|
926
|
-
path: resolvedPath,
|
|
927
|
-
body,
|
|
928
|
-
});
|
|
576
|
+
b.m("PATCH").h(headers).b(body);
|
|
577
|
+
return b.build();
|
|
929
578
|
};
|
|
930
579
|
export const se_UpdateListenerCommand = async (input, context) => {
|
|
931
|
-
const
|
|
580
|
+
const b = rb(input, context);
|
|
932
581
|
const headers = {
|
|
933
582
|
"content-type": "application/json",
|
|
934
583
|
};
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
584
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}");
|
|
585
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
586
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
939
587
|
let body;
|
|
940
588
|
body = JSON.stringify(take(input, {
|
|
941
589
|
defaultAction: (_) => _json(_),
|
|
942
590
|
}));
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
hostname,
|
|
946
|
-
port,
|
|
947
|
-
method: "PATCH",
|
|
948
|
-
headers,
|
|
949
|
-
path: resolvedPath,
|
|
950
|
-
body,
|
|
951
|
-
});
|
|
591
|
+
b.m("PATCH").h(headers).b(body);
|
|
592
|
+
return b.build();
|
|
952
593
|
};
|
|
953
594
|
export const se_UpdateRuleCommand = async (input, context) => {
|
|
954
|
-
const
|
|
595
|
+
const b = rb(input, context);
|
|
955
596
|
const headers = {
|
|
956
597
|
"content-type": "application/json",
|
|
957
598
|
};
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
|
|
599
|
+
b.bp("/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}");
|
|
600
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
601
|
+
b.p("listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
|
|
602
|
+
b.p("ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
|
|
963
603
|
let body;
|
|
964
604
|
body = JSON.stringify(take(input, {
|
|
965
605
|
action: (_) => _json(_),
|
|
966
606
|
match: (_) => _json(_),
|
|
967
607
|
priority: [],
|
|
968
608
|
}));
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
hostname,
|
|
972
|
-
port,
|
|
973
|
-
method: "PATCH",
|
|
974
|
-
headers,
|
|
975
|
-
path: resolvedPath,
|
|
976
|
-
body,
|
|
977
|
-
});
|
|
609
|
+
b.m("PATCH").h(headers).b(body);
|
|
610
|
+
return b.build();
|
|
978
611
|
};
|
|
979
612
|
export const se_UpdateServiceCommand = async (input, context) => {
|
|
980
|
-
const
|
|
613
|
+
const b = rb(input, context);
|
|
981
614
|
const headers = {
|
|
982
615
|
"content-type": "application/json",
|
|
983
616
|
};
|
|
984
|
-
|
|
985
|
-
|
|
617
|
+
b.bp("/services/{serviceIdentifier}");
|
|
618
|
+
b.p("serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
|
|
986
619
|
let body;
|
|
987
620
|
body = JSON.stringify(take(input, {
|
|
988
621
|
authType: [],
|
|
989
622
|
certificateArn: [],
|
|
990
623
|
}));
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
hostname,
|
|
994
|
-
port,
|
|
995
|
-
method: "PATCH",
|
|
996
|
-
headers,
|
|
997
|
-
path: resolvedPath,
|
|
998
|
-
body,
|
|
999
|
-
});
|
|
624
|
+
b.m("PATCH").h(headers).b(body);
|
|
625
|
+
return b.build();
|
|
1000
626
|
};
|
|
1001
627
|
export const se_UpdateServiceNetworkCommand = async (input, context) => {
|
|
1002
|
-
const
|
|
628
|
+
const b = rb(input, context);
|
|
1003
629
|
const headers = {
|
|
1004
630
|
"content-type": "application/json",
|
|
1005
631
|
};
|
|
1006
|
-
|
|
1007
|
-
|
|
1008
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
|
|
632
|
+
b.bp("/servicenetworks/{serviceNetworkIdentifier}");
|
|
633
|
+
b.p("serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
|
|
1009
634
|
let body;
|
|
1010
635
|
body = JSON.stringify(take(input, {
|
|
1011
636
|
authType: [],
|
|
1012
637
|
}));
|
|
1013
|
-
|
|
1014
|
-
|
|
1015
|
-
hostname,
|
|
1016
|
-
port,
|
|
1017
|
-
method: "PATCH",
|
|
1018
|
-
headers,
|
|
1019
|
-
path: resolvedPath,
|
|
1020
|
-
body,
|
|
1021
|
-
});
|
|
638
|
+
b.m("PATCH").h(headers).b(body);
|
|
639
|
+
return b.build();
|
|
1022
640
|
};
|
|
1023
641
|
export const se_UpdateServiceNetworkVpcAssociationCommand = async (input, context) => {
|
|
1024
|
-
const
|
|
642
|
+
const b = rb(input, context);
|
|
1025
643
|
const headers = {
|
|
1026
644
|
"content-type": "application/json",
|
|
1027
645
|
};
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
|
|
646
|
+
b.bp("/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}");
|
|
647
|
+
b.p("serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
|
|
1031
648
|
let body;
|
|
1032
649
|
body = JSON.stringify(take(input, {
|
|
1033
650
|
securityGroupIds: (_) => _json(_),
|
|
1034
651
|
}));
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
hostname,
|
|
1038
|
-
port,
|
|
1039
|
-
method: "PATCH",
|
|
1040
|
-
headers,
|
|
1041
|
-
path: resolvedPath,
|
|
1042
|
-
body,
|
|
1043
|
-
});
|
|
652
|
+
b.m("PATCH").h(headers).b(body);
|
|
653
|
+
return b.build();
|
|
1044
654
|
};
|
|
1045
655
|
export const se_UpdateTargetGroupCommand = async (input, context) => {
|
|
1046
|
-
const
|
|
656
|
+
const b = rb(input, context);
|
|
1047
657
|
const headers = {
|
|
1048
658
|
"content-type": "application/json",
|
|
1049
659
|
};
|
|
1050
|
-
|
|
1051
|
-
|
|
660
|
+
b.bp("/targetgroups/{targetGroupIdentifier}");
|
|
661
|
+
b.p("targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
|
|
1052
662
|
let body;
|
|
1053
663
|
body = JSON.stringify(take(input, {
|
|
1054
664
|
healthCheck: (_) => _json(_),
|
|
1055
665
|
}));
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
hostname,
|
|
1059
|
-
port,
|
|
1060
|
-
method: "PATCH",
|
|
1061
|
-
headers,
|
|
1062
|
-
path: resolvedPath,
|
|
1063
|
-
body,
|
|
1064
|
-
});
|
|
666
|
+
b.m("PATCH").h(headers).b(body);
|
|
667
|
+
return b.build();
|
|
1065
668
|
};
|
|
1066
669
|
export const de_BatchUpdateRuleCommand = async (output, context) => {
|
|
1067
670
|
if (output.statusCode !== 200 && output.statusCode >= 300) {
|
|
@@ -3646,10 +3249,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
|
|
|
3646
3249
|
};
|
|
3647
3250
|
const de_InternalServerExceptionRes = async (parsedOutput, context) => {
|
|
3648
3251
|
const contents = map({
|
|
3649
|
-
|
|
3650
|
-
() => void 0 !== parsedOutput.headers["retry-after"],
|
|
3651
|
-
() => __strictParseInt32(parsedOutput.headers["retry-after"]),
|
|
3652
|
-
],
|
|
3252
|
+
[_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
|
|
3653
3253
|
});
|
|
3654
3254
|
const data = parsedOutput.body;
|
|
3655
3255
|
const doc = take(data, {
|
|
@@ -3696,10 +3296,7 @@ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
|
|
|
3696
3296
|
};
|
|
3697
3297
|
const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
|
|
3698
3298
|
const contents = map({
|
|
3699
|
-
|
|
3700
|
-
() => void 0 !== parsedOutput.headers["retry-after"],
|
|
3701
|
-
() => __strictParseInt32(parsedOutput.headers["retry-after"]),
|
|
3702
|
-
],
|
|
3299
|
+
[_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
|
|
3703
3300
|
});
|
|
3704
3301
|
const data = parsedOutput.body;
|
|
3705
3302
|
const doc = take(data, {
|
|
@@ -3909,6 +3506,16 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
|
|
|
3909
3506
|
value !== "" &&
|
|
3910
3507
|
(!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
|
|
3911
3508
|
(!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
|
|
3509
|
+
const _mR = "maxResults";
|
|
3510
|
+
const _nT = "nextToken";
|
|
3511
|
+
const _rAS = "retryAfterSeconds";
|
|
3512
|
+
const _rI = "resourceIdentifier";
|
|
3513
|
+
const _ra = "retry-after";
|
|
3514
|
+
const _sI = "serviceIdentifier";
|
|
3515
|
+
const _sNI = "serviceNetworkIdentifier";
|
|
3516
|
+
const _tGT = "targetGroupType";
|
|
3517
|
+
const _tK = "tagKeys";
|
|
3518
|
+
const _vI = "vpcIdentifier";
|
|
3912
3519
|
const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
|
|
3913
3520
|
if (encoded.length) {
|
|
3914
3521
|
return JSON.parse(encoded);
|