@aws-sdk/client-apigatewayv2 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 +451 -980
- package/dist-es/protocols/Aws_restJson1.js +452 -981
- package/package.json +5 -4
|
@@ -1,13 +1,13 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset,
|
|
1
|
+
import { requestBuilder as rb } from "@smithy/core";
|
|
2
|
+
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
|
|
3
3
|
import { ApiGatewayV2ServiceException as __BaseException } from "../models/ApiGatewayV2ServiceException";
|
|
4
4
|
import { AccessDeniedException, BadRequestException, ConflictException, NotFoundException, TooManyRequestsException, } from "../models/models_0";
|
|
5
5
|
export const se_CreateApiCommand = async (input, context) => {
|
|
6
|
-
const
|
|
6
|
+
const b = rb(input, context);
|
|
7
7
|
const headers = {
|
|
8
8
|
"content-type": "application/json",
|
|
9
9
|
};
|
|
10
|
-
|
|
10
|
+
b.bp("/v2/apis");
|
|
11
11
|
let body;
|
|
12
12
|
body = JSON.stringify(take(input, {
|
|
13
13
|
apiKeySelectionExpression: [, , `ApiKeySelectionExpression`],
|
|
@@ -24,46 +24,32 @@ export const se_CreateApiCommand = async (input, context) => {
|
|
|
24
24
|
target: [, , `Target`],
|
|
25
25
|
version: [, , `Version`],
|
|
26
26
|
}));
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
hostname,
|
|
30
|
-
port,
|
|
31
|
-
method: "POST",
|
|
32
|
-
headers,
|
|
33
|
-
path: resolvedPath,
|
|
34
|
-
body,
|
|
35
|
-
});
|
|
27
|
+
b.m("POST").h(headers).b(body);
|
|
28
|
+
return b.build();
|
|
36
29
|
};
|
|
37
30
|
export const se_CreateApiMappingCommand = async (input, context) => {
|
|
38
|
-
const
|
|
31
|
+
const b = rb(input, context);
|
|
39
32
|
const headers = {
|
|
40
33
|
"content-type": "application/json",
|
|
41
34
|
};
|
|
42
|
-
|
|
43
|
-
|
|
35
|
+
b.bp("/v2/domainnames/{DomainName}/apimappings");
|
|
36
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
44
37
|
let body;
|
|
45
38
|
body = JSON.stringify(take(input, {
|
|
46
39
|
apiId: [, , `ApiId`],
|
|
47
40
|
apiMappingKey: [, , `ApiMappingKey`],
|
|
48
41
|
stage: [, , `Stage`],
|
|
49
42
|
}));
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
hostname,
|
|
53
|
-
port,
|
|
54
|
-
method: "POST",
|
|
55
|
-
headers,
|
|
56
|
-
path: resolvedPath,
|
|
57
|
-
body,
|
|
58
|
-
});
|
|
43
|
+
b.m("POST").h(headers).b(body);
|
|
44
|
+
return b.build();
|
|
59
45
|
};
|
|
60
46
|
export const se_CreateAuthorizerCommand = async (input, context) => {
|
|
61
|
-
const
|
|
47
|
+
const b = rb(input, context);
|
|
62
48
|
const headers = {
|
|
63
49
|
"content-type": "application/json",
|
|
64
50
|
};
|
|
65
|
-
|
|
66
|
-
|
|
51
|
+
b.bp("/v2/apis/{ApiId}/authorizers");
|
|
52
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
67
53
|
let body;
|
|
68
54
|
body = JSON.stringify(take(input, {
|
|
69
55
|
authorizerCredentialsArn: [, , `AuthorizerCredentialsArn`],
|
|
@@ -77,44 +63,30 @@ export const se_CreateAuthorizerCommand = async (input, context) => {
|
|
|
77
63
|
jwtConfiguration: [, (_) => se_JWTConfiguration(_, context), `JwtConfiguration`],
|
|
78
64
|
name: [, , `Name`],
|
|
79
65
|
}));
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
hostname,
|
|
83
|
-
port,
|
|
84
|
-
method: "POST",
|
|
85
|
-
headers,
|
|
86
|
-
path: resolvedPath,
|
|
87
|
-
body,
|
|
88
|
-
});
|
|
66
|
+
b.m("POST").h(headers).b(body);
|
|
67
|
+
return b.build();
|
|
89
68
|
};
|
|
90
69
|
export const se_CreateDeploymentCommand = async (input, context) => {
|
|
91
|
-
const
|
|
70
|
+
const b = rb(input, context);
|
|
92
71
|
const headers = {
|
|
93
72
|
"content-type": "application/json",
|
|
94
73
|
};
|
|
95
|
-
|
|
96
|
-
|
|
74
|
+
b.bp("/v2/apis/{ApiId}/deployments");
|
|
75
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
97
76
|
let body;
|
|
98
77
|
body = JSON.stringify(take(input, {
|
|
99
78
|
description: [, , `Description`],
|
|
100
79
|
stageName: [, , `StageName`],
|
|
101
80
|
}));
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
hostname,
|
|
105
|
-
port,
|
|
106
|
-
method: "POST",
|
|
107
|
-
headers,
|
|
108
|
-
path: resolvedPath,
|
|
109
|
-
body,
|
|
110
|
-
});
|
|
81
|
+
b.m("POST").h(headers).b(body);
|
|
82
|
+
return b.build();
|
|
111
83
|
};
|
|
112
84
|
export const se_CreateDomainNameCommand = async (input, context) => {
|
|
113
|
-
const
|
|
85
|
+
const b = rb(input, context);
|
|
114
86
|
const headers = {
|
|
115
87
|
"content-type": "application/json",
|
|
116
88
|
};
|
|
117
|
-
|
|
89
|
+
b.bp("/v2/domainnames");
|
|
118
90
|
let body;
|
|
119
91
|
body = JSON.stringify(take(input, {
|
|
120
92
|
domainName: [, , `DomainName`],
|
|
@@ -122,23 +94,16 @@ export const se_CreateDomainNameCommand = async (input, context) => {
|
|
|
122
94
|
mutualTlsAuthentication: [, (_) => se_MutualTlsAuthenticationInput(_, context), `MutualTlsAuthentication`],
|
|
123
95
|
tags: [, (_) => _json(_), `Tags`],
|
|
124
96
|
}));
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
hostname,
|
|
128
|
-
port,
|
|
129
|
-
method: "POST",
|
|
130
|
-
headers,
|
|
131
|
-
path: resolvedPath,
|
|
132
|
-
body,
|
|
133
|
-
});
|
|
97
|
+
b.m("POST").h(headers).b(body);
|
|
98
|
+
return b.build();
|
|
134
99
|
};
|
|
135
100
|
export const se_CreateIntegrationCommand = async (input, context) => {
|
|
136
|
-
const
|
|
101
|
+
const b = rb(input, context);
|
|
137
102
|
const headers = {
|
|
138
103
|
"content-type": "application/json",
|
|
139
104
|
};
|
|
140
|
-
|
|
141
|
-
|
|
105
|
+
b.bp("/v2/apis/{ApiId}/integrations");
|
|
106
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
142
107
|
let body;
|
|
143
108
|
body = JSON.stringify(take(input, {
|
|
144
109
|
connectionId: [, , `ConnectionId`],
|
|
@@ -159,25 +124,17 @@ export const se_CreateIntegrationCommand = async (input, context) => {
|
|
|
159
124
|
timeoutInMillis: [, , `TimeoutInMillis`],
|
|
160
125
|
tlsConfig: [, (_) => se_TlsConfigInput(_, context), `TlsConfig`],
|
|
161
126
|
}));
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
hostname,
|
|
165
|
-
port,
|
|
166
|
-
method: "POST",
|
|
167
|
-
headers,
|
|
168
|
-
path: resolvedPath,
|
|
169
|
-
body,
|
|
170
|
-
});
|
|
127
|
+
b.m("POST").h(headers).b(body);
|
|
128
|
+
return b.build();
|
|
171
129
|
};
|
|
172
130
|
export const se_CreateIntegrationResponseCommand = async (input, context) => {
|
|
173
|
-
const
|
|
131
|
+
const b = rb(input, context);
|
|
174
132
|
const headers = {
|
|
175
133
|
"content-type": "application/json",
|
|
176
134
|
};
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
135
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}/integrationresponses");
|
|
136
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
137
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
181
138
|
let body;
|
|
182
139
|
body = JSON.stringify(take(input, {
|
|
183
140
|
contentHandlingStrategy: [, , `ContentHandlingStrategy`],
|
|
@@ -186,23 +143,16 @@ export const se_CreateIntegrationResponseCommand = async (input, context) => {
|
|
|
186
143
|
responseTemplates: [, (_) => _json(_), `ResponseTemplates`],
|
|
187
144
|
templateSelectionExpression: [, , `TemplateSelectionExpression`],
|
|
188
145
|
}));
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
hostname,
|
|
192
|
-
port,
|
|
193
|
-
method: "POST",
|
|
194
|
-
headers,
|
|
195
|
-
path: resolvedPath,
|
|
196
|
-
body,
|
|
197
|
-
});
|
|
146
|
+
b.m("POST").h(headers).b(body);
|
|
147
|
+
return b.build();
|
|
198
148
|
};
|
|
199
149
|
export const se_CreateModelCommand = async (input, context) => {
|
|
200
|
-
const
|
|
150
|
+
const b = rb(input, context);
|
|
201
151
|
const headers = {
|
|
202
152
|
"content-type": "application/json",
|
|
203
153
|
};
|
|
204
|
-
|
|
205
|
-
|
|
154
|
+
b.bp("/v2/apis/{ApiId}/models");
|
|
155
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
206
156
|
let body;
|
|
207
157
|
body = JSON.stringify(take(input, {
|
|
208
158
|
contentType: [, , `ContentType`],
|
|
@@ -210,23 +160,16 @@ export const se_CreateModelCommand = async (input, context) => {
|
|
|
210
160
|
name: [, , `Name`],
|
|
211
161
|
schema: [, , `Schema`],
|
|
212
162
|
}));
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
hostname,
|
|
216
|
-
port,
|
|
217
|
-
method: "POST",
|
|
218
|
-
headers,
|
|
219
|
-
path: resolvedPath,
|
|
220
|
-
body,
|
|
221
|
-
});
|
|
163
|
+
b.m("POST").h(headers).b(body);
|
|
164
|
+
return b.build();
|
|
222
165
|
};
|
|
223
166
|
export const se_CreateRouteCommand = async (input, context) => {
|
|
224
|
-
const
|
|
167
|
+
const b = rb(input, context);
|
|
225
168
|
const headers = {
|
|
226
169
|
"content-type": "application/json",
|
|
227
170
|
};
|
|
228
|
-
|
|
229
|
-
|
|
171
|
+
b.bp("/v2/apis/{ApiId}/routes");
|
|
172
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
230
173
|
let body;
|
|
231
174
|
body = JSON.stringify(take(input, {
|
|
232
175
|
apiKeyRequired: [, , `ApiKeyRequired`],
|
|
@@ -241,25 +184,17 @@ export const se_CreateRouteCommand = async (input, context) => {
|
|
|
241
184
|
routeResponseSelectionExpression: [, , `RouteResponseSelectionExpression`],
|
|
242
185
|
target: [, , `Target`],
|
|
243
186
|
}));
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
hostname,
|
|
247
|
-
port,
|
|
248
|
-
method: "POST",
|
|
249
|
-
headers,
|
|
250
|
-
path: resolvedPath,
|
|
251
|
-
body,
|
|
252
|
-
});
|
|
187
|
+
b.m("POST").h(headers).b(body);
|
|
188
|
+
return b.build();
|
|
253
189
|
};
|
|
254
190
|
export const se_CreateRouteResponseCommand = async (input, context) => {
|
|
255
|
-
const
|
|
191
|
+
const b = rb(input, context);
|
|
256
192
|
const headers = {
|
|
257
193
|
"content-type": "application/json",
|
|
258
194
|
};
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "RouteId", () => input.RouteId, "{RouteId}", false);
|
|
195
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}/routeresponses");
|
|
196
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
197
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
263
198
|
let body;
|
|
264
199
|
body = JSON.stringify(take(input, {
|
|
265
200
|
modelSelectionExpression: [, , `ModelSelectionExpression`],
|
|
@@ -267,23 +202,16 @@ export const se_CreateRouteResponseCommand = async (input, context) => {
|
|
|
267
202
|
responseParameters: [, (_) => se_RouteParameters(_, context), `ResponseParameters`],
|
|
268
203
|
routeResponseKey: [, , `RouteResponseKey`],
|
|
269
204
|
}));
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
hostname,
|
|
273
|
-
port,
|
|
274
|
-
method: "POST",
|
|
275
|
-
headers,
|
|
276
|
-
path: resolvedPath,
|
|
277
|
-
body,
|
|
278
|
-
});
|
|
205
|
+
b.m("POST").h(headers).b(body);
|
|
206
|
+
return b.build();
|
|
279
207
|
};
|
|
280
208
|
export const se_CreateStageCommand = async (input, context) => {
|
|
281
|
-
const
|
|
209
|
+
const b = rb(input, context);
|
|
282
210
|
const headers = {
|
|
283
211
|
"content-type": "application/json",
|
|
284
212
|
};
|
|
285
|
-
|
|
286
|
-
|
|
213
|
+
b.bp("/v2/apis/{ApiId}/stages");
|
|
214
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
287
215
|
let body;
|
|
288
216
|
body = JSON.stringify(take(input, {
|
|
289
217
|
accessLogSettings: [, (_) => se_AccessLogSettings(_, context), `AccessLogSettings`],
|
|
@@ -297,22 +225,15 @@ export const se_CreateStageCommand = async (input, context) => {
|
|
|
297
225
|
stageVariables: [, (_) => _json(_), `StageVariables`],
|
|
298
226
|
tags: [, (_) => _json(_), `Tags`],
|
|
299
227
|
}));
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
hostname,
|
|
303
|
-
port,
|
|
304
|
-
method: "POST",
|
|
305
|
-
headers,
|
|
306
|
-
path: resolvedPath,
|
|
307
|
-
body,
|
|
308
|
-
});
|
|
228
|
+
b.m("POST").h(headers).b(body);
|
|
229
|
+
return b.build();
|
|
309
230
|
};
|
|
310
231
|
export const se_CreateVpcLinkCommand = async (input, context) => {
|
|
311
|
-
const
|
|
232
|
+
const b = rb(input, context);
|
|
312
233
|
const headers = {
|
|
313
234
|
"content-type": "application/json",
|
|
314
235
|
};
|
|
315
|
-
|
|
236
|
+
b.bp("/v2/vpclinks");
|
|
316
237
|
let body;
|
|
317
238
|
body = JSON.stringify(take(input, {
|
|
318
239
|
name: [, , `Name`],
|
|
@@ -320,937 +241,559 @@ export const se_CreateVpcLinkCommand = async (input, context) => {
|
|
|
320
241
|
subnetIds: [, (_) => _json(_), `SubnetIds`],
|
|
321
242
|
tags: [, (_) => _json(_), `Tags`],
|
|
322
243
|
}));
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
hostname,
|
|
326
|
-
port,
|
|
327
|
-
method: "POST",
|
|
328
|
-
headers,
|
|
329
|
-
path: resolvedPath,
|
|
330
|
-
body,
|
|
331
|
-
});
|
|
244
|
+
b.m("POST").h(headers).b(body);
|
|
245
|
+
return b.build();
|
|
332
246
|
};
|
|
333
247
|
export const se_DeleteAccessLogSettingsCommand = async (input, context) => {
|
|
334
|
-
const
|
|
248
|
+
const b = rb(input, context);
|
|
335
249
|
const headers = {};
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "StageName", () => input.StageName, "{StageName}", false);
|
|
250
|
+
b.bp("/v2/apis/{ApiId}/stages/{StageName}/accesslogsettings");
|
|
251
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
252
|
+
b.p("StageName", () => input.StageName, "{StageName}", false);
|
|
340
253
|
let body;
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
hostname,
|
|
344
|
-
port,
|
|
345
|
-
method: "DELETE",
|
|
346
|
-
headers,
|
|
347
|
-
path: resolvedPath,
|
|
348
|
-
body,
|
|
349
|
-
});
|
|
254
|
+
b.m("DELETE").h(headers).b(body);
|
|
255
|
+
return b.build();
|
|
350
256
|
};
|
|
351
257
|
export const se_DeleteApiCommand = async (input, context) => {
|
|
352
|
-
const
|
|
258
|
+
const b = rb(input, context);
|
|
353
259
|
const headers = {};
|
|
354
|
-
|
|
355
|
-
|
|
260
|
+
b.bp("/v2/apis/{ApiId}");
|
|
261
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
356
262
|
let body;
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
hostname,
|
|
360
|
-
port,
|
|
361
|
-
method: "DELETE",
|
|
362
|
-
headers,
|
|
363
|
-
path: resolvedPath,
|
|
364
|
-
body,
|
|
365
|
-
});
|
|
263
|
+
b.m("DELETE").h(headers).b(body);
|
|
264
|
+
return b.build();
|
|
366
265
|
};
|
|
367
266
|
export const se_DeleteApiMappingCommand = async (input, context) => {
|
|
368
|
-
const
|
|
267
|
+
const b = rb(input, context);
|
|
369
268
|
const headers = {};
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
269
|
+
b.bp("/v2/domainnames/{DomainName}/apimappings/{ApiMappingId}");
|
|
270
|
+
b.p("ApiMappingId", () => input.ApiMappingId, "{ApiMappingId}", false);
|
|
271
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
374
272
|
let body;
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
hostname,
|
|
378
|
-
port,
|
|
379
|
-
method: "DELETE",
|
|
380
|
-
headers,
|
|
381
|
-
path: resolvedPath,
|
|
382
|
-
body,
|
|
383
|
-
});
|
|
273
|
+
b.m("DELETE").h(headers).b(body);
|
|
274
|
+
return b.build();
|
|
384
275
|
};
|
|
385
276
|
export const se_DeleteAuthorizerCommand = async (input, context) => {
|
|
386
|
-
const
|
|
277
|
+
const b = rb(input, context);
|
|
387
278
|
const headers = {};
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "AuthorizerId", () => input.AuthorizerId, "{AuthorizerId}", false);
|
|
279
|
+
b.bp("/v2/apis/{ApiId}/authorizers/{AuthorizerId}");
|
|
280
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
281
|
+
b.p("AuthorizerId", () => input.AuthorizerId, "{AuthorizerId}", false);
|
|
392
282
|
let body;
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
hostname,
|
|
396
|
-
port,
|
|
397
|
-
method: "DELETE",
|
|
398
|
-
headers,
|
|
399
|
-
path: resolvedPath,
|
|
400
|
-
body,
|
|
401
|
-
});
|
|
283
|
+
b.m("DELETE").h(headers).b(body);
|
|
284
|
+
return b.build();
|
|
402
285
|
};
|
|
403
286
|
export const se_DeleteCorsConfigurationCommand = async (input, context) => {
|
|
404
|
-
const
|
|
287
|
+
const b = rb(input, context);
|
|
405
288
|
const headers = {};
|
|
406
|
-
|
|
407
|
-
|
|
289
|
+
b.bp("/v2/apis/{ApiId}/cors");
|
|
290
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
408
291
|
let body;
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
hostname,
|
|
412
|
-
port,
|
|
413
|
-
method: "DELETE",
|
|
414
|
-
headers,
|
|
415
|
-
path: resolvedPath,
|
|
416
|
-
body,
|
|
417
|
-
});
|
|
292
|
+
b.m("DELETE").h(headers).b(body);
|
|
293
|
+
return b.build();
|
|
418
294
|
};
|
|
419
295
|
export const se_DeleteDeploymentCommand = async (input, context) => {
|
|
420
|
-
const
|
|
296
|
+
const b = rb(input, context);
|
|
421
297
|
const headers = {};
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
|
|
298
|
+
b.bp("/v2/apis/{ApiId}/deployments/{DeploymentId}");
|
|
299
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
300
|
+
b.p("DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
|
|
426
301
|
let body;
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
hostname,
|
|
430
|
-
port,
|
|
431
|
-
method: "DELETE",
|
|
432
|
-
headers,
|
|
433
|
-
path: resolvedPath,
|
|
434
|
-
body,
|
|
435
|
-
});
|
|
302
|
+
b.m("DELETE").h(headers).b(body);
|
|
303
|
+
return b.build();
|
|
436
304
|
};
|
|
437
305
|
export const se_DeleteDomainNameCommand = async (input, context) => {
|
|
438
|
-
const
|
|
306
|
+
const b = rb(input, context);
|
|
439
307
|
const headers = {};
|
|
440
|
-
|
|
441
|
-
|
|
308
|
+
b.bp("/v2/domainnames/{DomainName}");
|
|
309
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
442
310
|
let body;
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
hostname,
|
|
446
|
-
port,
|
|
447
|
-
method: "DELETE",
|
|
448
|
-
headers,
|
|
449
|
-
path: resolvedPath,
|
|
450
|
-
body,
|
|
451
|
-
});
|
|
311
|
+
b.m("DELETE").h(headers).b(body);
|
|
312
|
+
return b.build();
|
|
452
313
|
};
|
|
453
314
|
export const se_DeleteIntegrationCommand = async (input, context) => {
|
|
454
|
-
const
|
|
315
|
+
const b = rb(input, context);
|
|
455
316
|
const headers = {};
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
317
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}");
|
|
318
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
319
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
460
320
|
let body;
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
hostname,
|
|
464
|
-
port,
|
|
465
|
-
method: "DELETE",
|
|
466
|
-
headers,
|
|
467
|
-
path: resolvedPath,
|
|
468
|
-
body,
|
|
469
|
-
});
|
|
321
|
+
b.m("DELETE").h(headers).b(body);
|
|
322
|
+
return b.build();
|
|
470
323
|
};
|
|
471
324
|
export const se_DeleteIntegrationResponseCommand = async (input, context) => {
|
|
472
|
-
const
|
|
325
|
+
const b = rb(input, context);
|
|
473
326
|
const headers = {};
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationResponseId", () => input.IntegrationResponseId, "{IntegrationResponseId}", false);
|
|
327
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}/integrationresponses/{IntegrationResponseId}");
|
|
328
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
329
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
330
|
+
b.p("IntegrationResponseId", () => input.IntegrationResponseId, "{IntegrationResponseId}", false);
|
|
479
331
|
let body;
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
hostname,
|
|
483
|
-
port,
|
|
484
|
-
method: "DELETE",
|
|
485
|
-
headers,
|
|
486
|
-
path: resolvedPath,
|
|
487
|
-
body,
|
|
488
|
-
});
|
|
332
|
+
b.m("DELETE").h(headers).b(body);
|
|
333
|
+
return b.build();
|
|
489
334
|
};
|
|
490
335
|
export const se_DeleteModelCommand = async (input, context) => {
|
|
491
|
-
const
|
|
336
|
+
const b = rb(input, context);
|
|
492
337
|
const headers = {};
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
338
|
+
b.bp("/v2/apis/{ApiId}/models/{ModelId}");
|
|
339
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
340
|
+
b.p("ModelId", () => input.ModelId, "{ModelId}", false);
|
|
496
341
|
let body;
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
hostname,
|
|
500
|
-
port,
|
|
501
|
-
method: "DELETE",
|
|
502
|
-
headers,
|
|
503
|
-
path: resolvedPath,
|
|
504
|
-
body,
|
|
505
|
-
});
|
|
342
|
+
b.m("DELETE").h(headers).b(body);
|
|
343
|
+
return b.build();
|
|
506
344
|
};
|
|
507
345
|
export const se_DeleteRouteCommand = async (input, context) => {
|
|
508
|
-
const
|
|
346
|
+
const b = rb(input, context);
|
|
509
347
|
const headers = {};
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
348
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}");
|
|
349
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
350
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
513
351
|
let body;
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
hostname,
|
|
517
|
-
port,
|
|
518
|
-
method: "DELETE",
|
|
519
|
-
headers,
|
|
520
|
-
path: resolvedPath,
|
|
521
|
-
body,
|
|
522
|
-
});
|
|
352
|
+
b.m("DELETE").h(headers).b(body);
|
|
353
|
+
return b.build();
|
|
523
354
|
};
|
|
524
355
|
export const se_DeleteRouteRequestParameterCommand = async (input, context) => {
|
|
525
|
-
const
|
|
356
|
+
const b = rb(input, context);
|
|
526
357
|
const headers = {};
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "RouteId", () => input.RouteId, "{RouteId}", false);
|
|
358
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}/requestparameters/{RequestParameterKey}");
|
|
359
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
360
|
+
b.p("RequestParameterKey", () => input.RequestParameterKey, "{RequestParameterKey}", false);
|
|
361
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
532
362
|
let body;
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
hostname,
|
|
536
|
-
port,
|
|
537
|
-
method: "DELETE",
|
|
538
|
-
headers,
|
|
539
|
-
path: resolvedPath,
|
|
540
|
-
body,
|
|
541
|
-
});
|
|
363
|
+
b.m("DELETE").h(headers).b(body);
|
|
364
|
+
return b.build();
|
|
542
365
|
};
|
|
543
366
|
export const se_DeleteRouteResponseCommand = async (input, context) => {
|
|
544
|
-
const
|
|
367
|
+
const b = rb(input, context);
|
|
545
368
|
const headers = {};
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "RouteResponseId", () => input.RouteResponseId, "{RouteResponseId}", false);
|
|
369
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}/routeresponses/{RouteResponseId}");
|
|
370
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
371
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
372
|
+
b.p("RouteResponseId", () => input.RouteResponseId, "{RouteResponseId}", false);
|
|
551
373
|
let body;
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
hostname,
|
|
555
|
-
port,
|
|
556
|
-
method: "DELETE",
|
|
557
|
-
headers,
|
|
558
|
-
path: resolvedPath,
|
|
559
|
-
body,
|
|
560
|
-
});
|
|
374
|
+
b.m("DELETE").h(headers).b(body);
|
|
375
|
+
return b.build();
|
|
561
376
|
};
|
|
562
377
|
export const se_DeleteRouteSettingsCommand = async (input, context) => {
|
|
563
|
-
const
|
|
378
|
+
const b = rb(input, context);
|
|
564
379
|
const headers = {};
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "StageName", () => input.StageName, "{StageName}", false);
|
|
380
|
+
b.bp("/v2/apis/{ApiId}/stages/{StageName}/routesettings/{RouteKey}");
|
|
381
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
382
|
+
b.p("RouteKey", () => input.RouteKey, "{RouteKey}", false);
|
|
383
|
+
b.p("StageName", () => input.StageName, "{StageName}", false);
|
|
570
384
|
let body;
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
hostname,
|
|
574
|
-
port,
|
|
575
|
-
method: "DELETE",
|
|
576
|
-
headers,
|
|
577
|
-
path: resolvedPath,
|
|
578
|
-
body,
|
|
579
|
-
});
|
|
385
|
+
b.m("DELETE").h(headers).b(body);
|
|
386
|
+
return b.build();
|
|
580
387
|
};
|
|
581
388
|
export const se_DeleteStageCommand = async (input, context) => {
|
|
582
|
-
const
|
|
389
|
+
const b = rb(input, context);
|
|
583
390
|
const headers = {};
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
391
|
+
b.bp("/v2/apis/{ApiId}/stages/{StageName}");
|
|
392
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
393
|
+
b.p("StageName", () => input.StageName, "{StageName}", false);
|
|
587
394
|
let body;
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
hostname,
|
|
591
|
-
port,
|
|
592
|
-
method: "DELETE",
|
|
593
|
-
headers,
|
|
594
|
-
path: resolvedPath,
|
|
595
|
-
body,
|
|
596
|
-
});
|
|
395
|
+
b.m("DELETE").h(headers).b(body);
|
|
396
|
+
return b.build();
|
|
597
397
|
};
|
|
598
398
|
export const se_DeleteVpcLinkCommand = async (input, context) => {
|
|
599
|
-
const
|
|
399
|
+
const b = rb(input, context);
|
|
600
400
|
const headers = {};
|
|
601
|
-
|
|
602
|
-
|
|
401
|
+
b.bp("/v2/vpclinks/{VpcLinkId}");
|
|
402
|
+
b.p("VpcLinkId", () => input.VpcLinkId, "{VpcLinkId}", false);
|
|
603
403
|
let body;
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
hostname,
|
|
607
|
-
port,
|
|
608
|
-
method: "DELETE",
|
|
609
|
-
headers,
|
|
610
|
-
path: resolvedPath,
|
|
611
|
-
body,
|
|
612
|
-
});
|
|
404
|
+
b.m("DELETE").h(headers).b(body);
|
|
405
|
+
return b.build();
|
|
613
406
|
};
|
|
614
407
|
export const se_ExportApiCommand = async (input, context) => {
|
|
615
|
-
const
|
|
408
|
+
const b = rb(input, context);
|
|
616
409
|
const headers = {};
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
410
|
+
b.bp("/v2/apis/{ApiId}/exports/{Specification}");
|
|
411
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
412
|
+
b.p("Specification", () => input.Specification, "{Specification}", false);
|
|
620
413
|
const query = map({
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
414
|
+
[_eV]: [, input[_EV]],
|
|
415
|
+
[_iE]: [() => input.IncludeExtensions !== void 0, () => input[_IE].toString()],
|
|
416
|
+
[_oT]: [, __expectNonNull(input[_OT], `OutputType`)],
|
|
417
|
+
[_sN]: [, input[_SN]],
|
|
625
418
|
});
|
|
626
419
|
let body;
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
hostname,
|
|
630
|
-
port,
|
|
631
|
-
method: "GET",
|
|
632
|
-
headers,
|
|
633
|
-
path: resolvedPath,
|
|
634
|
-
query,
|
|
635
|
-
body,
|
|
636
|
-
});
|
|
420
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
421
|
+
return b.build();
|
|
637
422
|
};
|
|
638
423
|
export const se_GetApiCommand = async (input, context) => {
|
|
639
|
-
const
|
|
424
|
+
const b = rb(input, context);
|
|
640
425
|
const headers = {};
|
|
641
|
-
|
|
642
|
-
|
|
426
|
+
b.bp("/v2/apis/{ApiId}");
|
|
427
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
643
428
|
let body;
|
|
644
|
-
|
|
645
|
-
|
|
646
|
-
hostname,
|
|
647
|
-
port,
|
|
648
|
-
method: "GET",
|
|
649
|
-
headers,
|
|
650
|
-
path: resolvedPath,
|
|
651
|
-
body,
|
|
652
|
-
});
|
|
429
|
+
b.m("GET").h(headers).b(body);
|
|
430
|
+
return b.build();
|
|
653
431
|
};
|
|
654
432
|
export const se_GetApiMappingCommand = async (input, context) => {
|
|
655
|
-
const
|
|
433
|
+
const b = rb(input, context);
|
|
656
434
|
const headers = {};
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
435
|
+
b.bp("/v2/domainnames/{DomainName}/apimappings/{ApiMappingId}");
|
|
436
|
+
b.p("ApiMappingId", () => input.ApiMappingId, "{ApiMappingId}", false);
|
|
437
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
661
438
|
let body;
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
hostname,
|
|
665
|
-
port,
|
|
666
|
-
method: "GET",
|
|
667
|
-
headers,
|
|
668
|
-
path: resolvedPath,
|
|
669
|
-
body,
|
|
670
|
-
});
|
|
439
|
+
b.m("GET").h(headers).b(body);
|
|
440
|
+
return b.build();
|
|
671
441
|
};
|
|
672
442
|
export const se_GetApiMappingsCommand = async (input, context) => {
|
|
673
|
-
const
|
|
443
|
+
const b = rb(input, context);
|
|
674
444
|
const headers = {};
|
|
675
|
-
|
|
676
|
-
|
|
445
|
+
b.bp("/v2/domainnames/{DomainName}/apimappings");
|
|
446
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
677
447
|
const query = map({
|
|
678
|
-
|
|
679
|
-
|
|
448
|
+
[_mR]: [, input[_MR]],
|
|
449
|
+
[_nT]: [, input[_NT]],
|
|
680
450
|
});
|
|
681
451
|
let body;
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
hostname,
|
|
685
|
-
port,
|
|
686
|
-
method: "GET",
|
|
687
|
-
headers,
|
|
688
|
-
path: resolvedPath,
|
|
689
|
-
query,
|
|
690
|
-
body,
|
|
691
|
-
});
|
|
452
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
453
|
+
return b.build();
|
|
692
454
|
};
|
|
693
455
|
export const se_GetApisCommand = async (input, context) => {
|
|
694
|
-
const
|
|
456
|
+
const b = rb(input, context);
|
|
695
457
|
const headers = {};
|
|
696
|
-
|
|
458
|
+
b.bp("/v2/apis");
|
|
697
459
|
const query = map({
|
|
698
|
-
|
|
699
|
-
|
|
460
|
+
[_mR]: [, input[_MR]],
|
|
461
|
+
[_nT]: [, input[_NT]],
|
|
700
462
|
});
|
|
701
463
|
let body;
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
hostname,
|
|
705
|
-
port,
|
|
706
|
-
method: "GET",
|
|
707
|
-
headers,
|
|
708
|
-
path: resolvedPath,
|
|
709
|
-
query,
|
|
710
|
-
body,
|
|
711
|
-
});
|
|
464
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
465
|
+
return b.build();
|
|
712
466
|
};
|
|
713
467
|
export const se_GetAuthorizerCommand = async (input, context) => {
|
|
714
|
-
const
|
|
468
|
+
const b = rb(input, context);
|
|
715
469
|
const headers = {};
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "AuthorizerId", () => input.AuthorizerId, "{AuthorizerId}", false);
|
|
470
|
+
b.bp("/v2/apis/{ApiId}/authorizers/{AuthorizerId}");
|
|
471
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
472
|
+
b.p("AuthorizerId", () => input.AuthorizerId, "{AuthorizerId}", false);
|
|
720
473
|
let body;
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
hostname,
|
|
724
|
-
port,
|
|
725
|
-
method: "GET",
|
|
726
|
-
headers,
|
|
727
|
-
path: resolvedPath,
|
|
728
|
-
body,
|
|
729
|
-
});
|
|
474
|
+
b.m("GET").h(headers).b(body);
|
|
475
|
+
return b.build();
|
|
730
476
|
};
|
|
731
477
|
export const se_GetAuthorizersCommand = async (input, context) => {
|
|
732
|
-
const
|
|
478
|
+
const b = rb(input, context);
|
|
733
479
|
const headers = {};
|
|
734
|
-
|
|
735
|
-
|
|
480
|
+
b.bp("/v2/apis/{ApiId}/authorizers");
|
|
481
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
736
482
|
const query = map({
|
|
737
|
-
|
|
738
|
-
|
|
483
|
+
[_mR]: [, input[_MR]],
|
|
484
|
+
[_nT]: [, input[_NT]],
|
|
739
485
|
});
|
|
740
486
|
let body;
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
hostname,
|
|
744
|
-
port,
|
|
745
|
-
method: "GET",
|
|
746
|
-
headers,
|
|
747
|
-
path: resolvedPath,
|
|
748
|
-
query,
|
|
749
|
-
body,
|
|
750
|
-
});
|
|
487
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
488
|
+
return b.build();
|
|
751
489
|
};
|
|
752
490
|
export const se_GetDeploymentCommand = async (input, context) => {
|
|
753
|
-
const
|
|
491
|
+
const b = rb(input, context);
|
|
754
492
|
const headers = {};
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
|
|
493
|
+
b.bp("/v2/apis/{ApiId}/deployments/{DeploymentId}");
|
|
494
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
495
|
+
b.p("DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
|
|
759
496
|
let body;
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
hostname,
|
|
763
|
-
port,
|
|
764
|
-
method: "GET",
|
|
765
|
-
headers,
|
|
766
|
-
path: resolvedPath,
|
|
767
|
-
body,
|
|
768
|
-
});
|
|
497
|
+
b.m("GET").h(headers).b(body);
|
|
498
|
+
return b.build();
|
|
769
499
|
};
|
|
770
500
|
export const se_GetDeploymentsCommand = async (input, context) => {
|
|
771
|
-
const
|
|
501
|
+
const b = rb(input, context);
|
|
772
502
|
const headers = {};
|
|
773
|
-
|
|
774
|
-
|
|
503
|
+
b.bp("/v2/apis/{ApiId}/deployments");
|
|
504
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
775
505
|
const query = map({
|
|
776
|
-
|
|
777
|
-
|
|
506
|
+
[_mR]: [, input[_MR]],
|
|
507
|
+
[_nT]: [, input[_NT]],
|
|
778
508
|
});
|
|
779
509
|
let body;
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
hostname,
|
|
783
|
-
port,
|
|
784
|
-
method: "GET",
|
|
785
|
-
headers,
|
|
786
|
-
path: resolvedPath,
|
|
787
|
-
query,
|
|
788
|
-
body,
|
|
789
|
-
});
|
|
510
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
511
|
+
return b.build();
|
|
790
512
|
};
|
|
791
513
|
export const se_GetDomainNameCommand = async (input, context) => {
|
|
792
|
-
const
|
|
514
|
+
const b = rb(input, context);
|
|
793
515
|
const headers = {};
|
|
794
|
-
|
|
795
|
-
|
|
516
|
+
b.bp("/v2/domainnames/{DomainName}");
|
|
517
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
796
518
|
let body;
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
hostname,
|
|
800
|
-
port,
|
|
801
|
-
method: "GET",
|
|
802
|
-
headers,
|
|
803
|
-
path: resolvedPath,
|
|
804
|
-
body,
|
|
805
|
-
});
|
|
519
|
+
b.m("GET").h(headers).b(body);
|
|
520
|
+
return b.build();
|
|
806
521
|
};
|
|
807
522
|
export const se_GetDomainNamesCommand = async (input, context) => {
|
|
808
|
-
const
|
|
523
|
+
const b = rb(input, context);
|
|
809
524
|
const headers = {};
|
|
810
|
-
|
|
525
|
+
b.bp("/v2/domainnames");
|
|
811
526
|
const query = map({
|
|
812
|
-
|
|
813
|
-
|
|
527
|
+
[_mR]: [, input[_MR]],
|
|
528
|
+
[_nT]: [, input[_NT]],
|
|
814
529
|
});
|
|
815
530
|
let body;
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
hostname,
|
|
819
|
-
port,
|
|
820
|
-
method: "GET",
|
|
821
|
-
headers,
|
|
822
|
-
path: resolvedPath,
|
|
823
|
-
query,
|
|
824
|
-
body,
|
|
825
|
-
});
|
|
531
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
532
|
+
return b.build();
|
|
826
533
|
};
|
|
827
534
|
export const se_GetIntegrationCommand = async (input, context) => {
|
|
828
|
-
const
|
|
535
|
+
const b = rb(input, context);
|
|
829
536
|
const headers = {};
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
537
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}");
|
|
538
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
539
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
834
540
|
let body;
|
|
835
|
-
|
|
836
|
-
|
|
837
|
-
hostname,
|
|
838
|
-
port,
|
|
839
|
-
method: "GET",
|
|
840
|
-
headers,
|
|
841
|
-
path: resolvedPath,
|
|
842
|
-
body,
|
|
843
|
-
});
|
|
541
|
+
b.m("GET").h(headers).b(body);
|
|
542
|
+
return b.build();
|
|
844
543
|
};
|
|
845
544
|
export const se_GetIntegrationResponseCommand = async (input, context) => {
|
|
846
|
-
const
|
|
545
|
+
const b = rb(input, context);
|
|
847
546
|
const headers = {};
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationResponseId", () => input.IntegrationResponseId, "{IntegrationResponseId}", false);
|
|
547
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}/integrationresponses/{IntegrationResponseId}");
|
|
548
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
549
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
550
|
+
b.p("IntegrationResponseId", () => input.IntegrationResponseId, "{IntegrationResponseId}", false);
|
|
853
551
|
let body;
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
hostname,
|
|
857
|
-
port,
|
|
858
|
-
method: "GET",
|
|
859
|
-
headers,
|
|
860
|
-
path: resolvedPath,
|
|
861
|
-
body,
|
|
862
|
-
});
|
|
552
|
+
b.m("GET").h(headers).b(body);
|
|
553
|
+
return b.build();
|
|
863
554
|
};
|
|
864
555
|
export const se_GetIntegrationResponsesCommand = async (input, context) => {
|
|
865
|
-
const
|
|
556
|
+
const b = rb(input, context);
|
|
866
557
|
const headers = {};
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
558
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}/integrationresponses");
|
|
559
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
560
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
871
561
|
const query = map({
|
|
872
|
-
|
|
873
|
-
|
|
562
|
+
[_mR]: [, input[_MR]],
|
|
563
|
+
[_nT]: [, input[_NT]],
|
|
874
564
|
});
|
|
875
565
|
let body;
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
hostname,
|
|
879
|
-
port,
|
|
880
|
-
method: "GET",
|
|
881
|
-
headers,
|
|
882
|
-
path: resolvedPath,
|
|
883
|
-
query,
|
|
884
|
-
body,
|
|
885
|
-
});
|
|
566
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
567
|
+
return b.build();
|
|
886
568
|
};
|
|
887
569
|
export const se_GetIntegrationsCommand = async (input, context) => {
|
|
888
|
-
const
|
|
570
|
+
const b = rb(input, context);
|
|
889
571
|
const headers = {};
|
|
890
|
-
|
|
891
|
-
|
|
572
|
+
b.bp("/v2/apis/{ApiId}/integrations");
|
|
573
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
892
574
|
const query = map({
|
|
893
|
-
|
|
894
|
-
|
|
575
|
+
[_mR]: [, input[_MR]],
|
|
576
|
+
[_nT]: [, input[_NT]],
|
|
895
577
|
});
|
|
896
578
|
let body;
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
hostname,
|
|
900
|
-
port,
|
|
901
|
-
method: "GET",
|
|
902
|
-
headers,
|
|
903
|
-
path: resolvedPath,
|
|
904
|
-
query,
|
|
905
|
-
body,
|
|
906
|
-
});
|
|
579
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
580
|
+
return b.build();
|
|
907
581
|
};
|
|
908
582
|
export const se_GetModelCommand = async (input, context) => {
|
|
909
|
-
const
|
|
583
|
+
const b = rb(input, context);
|
|
910
584
|
const headers = {};
|
|
911
|
-
|
|
912
|
-
|
|
913
|
-
|
|
585
|
+
b.bp("/v2/apis/{ApiId}/models/{ModelId}");
|
|
586
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
587
|
+
b.p("ModelId", () => input.ModelId, "{ModelId}", false);
|
|
914
588
|
let body;
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
hostname,
|
|
918
|
-
port,
|
|
919
|
-
method: "GET",
|
|
920
|
-
headers,
|
|
921
|
-
path: resolvedPath,
|
|
922
|
-
body,
|
|
923
|
-
});
|
|
589
|
+
b.m("GET").h(headers).b(body);
|
|
590
|
+
return b.build();
|
|
924
591
|
};
|
|
925
592
|
export const se_GetModelsCommand = async (input, context) => {
|
|
926
|
-
const
|
|
593
|
+
const b = rb(input, context);
|
|
927
594
|
const headers = {};
|
|
928
|
-
|
|
929
|
-
|
|
595
|
+
b.bp("/v2/apis/{ApiId}/models");
|
|
596
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
930
597
|
const query = map({
|
|
931
|
-
|
|
932
|
-
|
|
598
|
+
[_mR]: [, input[_MR]],
|
|
599
|
+
[_nT]: [, input[_NT]],
|
|
933
600
|
});
|
|
934
601
|
let body;
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
hostname,
|
|
938
|
-
port,
|
|
939
|
-
method: "GET",
|
|
940
|
-
headers,
|
|
941
|
-
path: resolvedPath,
|
|
942
|
-
query,
|
|
943
|
-
body,
|
|
944
|
-
});
|
|
602
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
603
|
+
return b.build();
|
|
945
604
|
};
|
|
946
605
|
export const se_GetModelTemplateCommand = async (input, context) => {
|
|
947
|
-
const
|
|
606
|
+
const b = rb(input, context);
|
|
948
607
|
const headers = {};
|
|
949
|
-
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "ModelId", () => input.ModelId, "{ModelId}", false);
|
|
608
|
+
b.bp("/v2/apis/{ApiId}/models/{ModelId}/template");
|
|
609
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
610
|
+
b.p("ModelId", () => input.ModelId, "{ModelId}", false);
|
|
953
611
|
let body;
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
hostname,
|
|
957
|
-
port,
|
|
958
|
-
method: "GET",
|
|
959
|
-
headers,
|
|
960
|
-
path: resolvedPath,
|
|
961
|
-
body,
|
|
962
|
-
});
|
|
612
|
+
b.m("GET").h(headers).b(body);
|
|
613
|
+
return b.build();
|
|
963
614
|
};
|
|
964
615
|
export const se_GetRouteCommand = async (input, context) => {
|
|
965
|
-
const
|
|
616
|
+
const b = rb(input, context);
|
|
966
617
|
const headers = {};
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
|
|
618
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}");
|
|
619
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
620
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
970
621
|
let body;
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
hostname,
|
|
974
|
-
port,
|
|
975
|
-
method: "GET",
|
|
976
|
-
headers,
|
|
977
|
-
path: resolvedPath,
|
|
978
|
-
body,
|
|
979
|
-
});
|
|
622
|
+
b.m("GET").h(headers).b(body);
|
|
623
|
+
return b.build();
|
|
980
624
|
};
|
|
981
625
|
export const se_GetRouteResponseCommand = async (input, context) => {
|
|
982
|
-
const
|
|
626
|
+
const b = rb(input, context);
|
|
983
627
|
const headers = {};
|
|
984
|
-
|
|
985
|
-
|
|
986
|
-
|
|
987
|
-
|
|
988
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "RouteResponseId", () => input.RouteResponseId, "{RouteResponseId}", false);
|
|
628
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}/routeresponses/{RouteResponseId}");
|
|
629
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
630
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
631
|
+
b.p("RouteResponseId", () => input.RouteResponseId, "{RouteResponseId}", false);
|
|
989
632
|
let body;
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
hostname,
|
|
993
|
-
port,
|
|
994
|
-
method: "GET",
|
|
995
|
-
headers,
|
|
996
|
-
path: resolvedPath,
|
|
997
|
-
body,
|
|
998
|
-
});
|
|
633
|
+
b.m("GET").h(headers).b(body);
|
|
634
|
+
return b.build();
|
|
999
635
|
};
|
|
1000
636
|
export const se_GetRouteResponsesCommand = async (input, context) => {
|
|
1001
|
-
const
|
|
637
|
+
const b = rb(input, context);
|
|
1002
638
|
const headers = {};
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
|
|
1006
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "RouteId", () => input.RouteId, "{RouteId}", false);
|
|
639
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}/routeresponses");
|
|
640
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
641
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
1007
642
|
const query = map({
|
|
1008
|
-
|
|
1009
|
-
|
|
643
|
+
[_mR]: [, input[_MR]],
|
|
644
|
+
[_nT]: [, input[_NT]],
|
|
1010
645
|
});
|
|
1011
646
|
let body;
|
|
1012
|
-
|
|
1013
|
-
|
|
1014
|
-
hostname,
|
|
1015
|
-
port,
|
|
1016
|
-
method: "GET",
|
|
1017
|
-
headers,
|
|
1018
|
-
path: resolvedPath,
|
|
1019
|
-
query,
|
|
1020
|
-
body,
|
|
1021
|
-
});
|
|
647
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
648
|
+
return b.build();
|
|
1022
649
|
};
|
|
1023
650
|
export const se_GetRoutesCommand = async (input, context) => {
|
|
1024
|
-
const
|
|
651
|
+
const b = rb(input, context);
|
|
1025
652
|
const headers = {};
|
|
1026
|
-
|
|
1027
|
-
|
|
653
|
+
b.bp("/v2/apis/{ApiId}/routes");
|
|
654
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
1028
655
|
const query = map({
|
|
1029
|
-
|
|
1030
|
-
|
|
656
|
+
[_mR]: [, input[_MR]],
|
|
657
|
+
[_nT]: [, input[_NT]],
|
|
1031
658
|
});
|
|
1032
659
|
let body;
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
hostname,
|
|
1036
|
-
port,
|
|
1037
|
-
method: "GET",
|
|
1038
|
-
headers,
|
|
1039
|
-
path: resolvedPath,
|
|
1040
|
-
query,
|
|
1041
|
-
body,
|
|
1042
|
-
});
|
|
660
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
661
|
+
return b.build();
|
|
1043
662
|
};
|
|
1044
663
|
export const se_GetStageCommand = async (input, context) => {
|
|
1045
|
-
const
|
|
664
|
+
const b = rb(input, context);
|
|
1046
665
|
const headers = {};
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
|
|
666
|
+
b.bp("/v2/apis/{ApiId}/stages/{StageName}");
|
|
667
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
668
|
+
b.p("StageName", () => input.StageName, "{StageName}", false);
|
|
1050
669
|
let body;
|
|
1051
|
-
|
|
1052
|
-
|
|
1053
|
-
hostname,
|
|
1054
|
-
port,
|
|
1055
|
-
method: "GET",
|
|
1056
|
-
headers,
|
|
1057
|
-
path: resolvedPath,
|
|
1058
|
-
body,
|
|
1059
|
-
});
|
|
670
|
+
b.m("GET").h(headers).b(body);
|
|
671
|
+
return b.build();
|
|
1060
672
|
};
|
|
1061
673
|
export const se_GetStagesCommand = async (input, context) => {
|
|
1062
|
-
const
|
|
674
|
+
const b = rb(input, context);
|
|
1063
675
|
const headers = {};
|
|
1064
|
-
|
|
1065
|
-
|
|
676
|
+
b.bp("/v2/apis/{ApiId}/stages");
|
|
677
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
1066
678
|
const query = map({
|
|
1067
|
-
|
|
1068
|
-
|
|
679
|
+
[_mR]: [, input[_MR]],
|
|
680
|
+
[_nT]: [, input[_NT]],
|
|
1069
681
|
});
|
|
1070
682
|
let body;
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
hostname,
|
|
1074
|
-
port,
|
|
1075
|
-
method: "GET",
|
|
1076
|
-
headers,
|
|
1077
|
-
path: resolvedPath,
|
|
1078
|
-
query,
|
|
1079
|
-
body,
|
|
1080
|
-
});
|
|
683
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
684
|
+
return b.build();
|
|
1081
685
|
};
|
|
1082
686
|
export const se_GetTagsCommand = async (input, context) => {
|
|
1083
|
-
const
|
|
687
|
+
const b = rb(input, context);
|
|
1084
688
|
const headers = {};
|
|
1085
|
-
|
|
1086
|
-
|
|
689
|
+
b.bp("/v2/tags/{ResourceArn}");
|
|
690
|
+
b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
|
|
1087
691
|
let body;
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
hostname,
|
|
1091
|
-
port,
|
|
1092
|
-
method: "GET",
|
|
1093
|
-
headers,
|
|
1094
|
-
path: resolvedPath,
|
|
1095
|
-
body,
|
|
1096
|
-
});
|
|
692
|
+
b.m("GET").h(headers).b(body);
|
|
693
|
+
return b.build();
|
|
1097
694
|
};
|
|
1098
695
|
export const se_GetVpcLinkCommand = async (input, context) => {
|
|
1099
|
-
const
|
|
696
|
+
const b = rb(input, context);
|
|
1100
697
|
const headers = {};
|
|
1101
|
-
|
|
1102
|
-
|
|
698
|
+
b.bp("/v2/vpclinks/{VpcLinkId}");
|
|
699
|
+
b.p("VpcLinkId", () => input.VpcLinkId, "{VpcLinkId}", false);
|
|
1103
700
|
let body;
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
hostname,
|
|
1107
|
-
port,
|
|
1108
|
-
method: "GET",
|
|
1109
|
-
headers,
|
|
1110
|
-
path: resolvedPath,
|
|
1111
|
-
body,
|
|
1112
|
-
});
|
|
701
|
+
b.m("GET").h(headers).b(body);
|
|
702
|
+
return b.build();
|
|
1113
703
|
};
|
|
1114
704
|
export const se_GetVpcLinksCommand = async (input, context) => {
|
|
1115
|
-
const
|
|
705
|
+
const b = rb(input, context);
|
|
1116
706
|
const headers = {};
|
|
1117
|
-
|
|
707
|
+
b.bp("/v2/vpclinks");
|
|
1118
708
|
const query = map({
|
|
1119
|
-
|
|
1120
|
-
|
|
709
|
+
[_mR]: [, input[_MR]],
|
|
710
|
+
[_nT]: [, input[_NT]],
|
|
1121
711
|
});
|
|
1122
712
|
let body;
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
hostname,
|
|
1126
|
-
port,
|
|
1127
|
-
method: "GET",
|
|
1128
|
-
headers,
|
|
1129
|
-
path: resolvedPath,
|
|
1130
|
-
query,
|
|
1131
|
-
body,
|
|
1132
|
-
});
|
|
713
|
+
b.m("GET").h(headers).q(query).b(body);
|
|
714
|
+
return b.build();
|
|
1133
715
|
};
|
|
1134
716
|
export const se_ImportApiCommand = async (input, context) => {
|
|
1135
|
-
const
|
|
717
|
+
const b = rb(input, context);
|
|
1136
718
|
const headers = {
|
|
1137
719
|
"content-type": "application/json",
|
|
1138
720
|
};
|
|
1139
|
-
|
|
721
|
+
b.bp("/v2/apis");
|
|
1140
722
|
const query = map({
|
|
1141
|
-
|
|
1142
|
-
|
|
723
|
+
[_b]: [, input[_B]],
|
|
724
|
+
[_fOW]: [() => input.FailOnWarnings !== void 0, () => input[_FOW].toString()],
|
|
1143
725
|
});
|
|
1144
726
|
let body;
|
|
1145
727
|
body = JSON.stringify(take(input, {
|
|
1146
728
|
body: [, , `Body`],
|
|
1147
729
|
}));
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
hostname,
|
|
1151
|
-
port,
|
|
1152
|
-
method: "PUT",
|
|
1153
|
-
headers,
|
|
1154
|
-
path: resolvedPath,
|
|
1155
|
-
query,
|
|
1156
|
-
body,
|
|
1157
|
-
});
|
|
730
|
+
b.m("PUT").h(headers).q(query).b(body);
|
|
731
|
+
return b.build();
|
|
1158
732
|
};
|
|
1159
733
|
export const se_ReimportApiCommand = async (input, context) => {
|
|
1160
|
-
const
|
|
734
|
+
const b = rb(input, context);
|
|
1161
735
|
const headers = {
|
|
1162
736
|
"content-type": "application/json",
|
|
1163
737
|
};
|
|
1164
|
-
|
|
1165
|
-
|
|
738
|
+
b.bp("/v2/apis/{ApiId}");
|
|
739
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
1166
740
|
const query = map({
|
|
1167
|
-
|
|
1168
|
-
|
|
741
|
+
[_b]: [, input[_B]],
|
|
742
|
+
[_fOW]: [() => input.FailOnWarnings !== void 0, () => input[_FOW].toString()],
|
|
1169
743
|
});
|
|
1170
744
|
let body;
|
|
1171
745
|
body = JSON.stringify(take(input, {
|
|
1172
746
|
body: [, , `Body`],
|
|
1173
747
|
}));
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
hostname,
|
|
1177
|
-
port,
|
|
1178
|
-
method: "PUT",
|
|
1179
|
-
headers,
|
|
1180
|
-
path: resolvedPath,
|
|
1181
|
-
query,
|
|
1182
|
-
body,
|
|
1183
|
-
});
|
|
748
|
+
b.m("PUT").h(headers).q(query).b(body);
|
|
749
|
+
return b.build();
|
|
1184
750
|
};
|
|
1185
751
|
export const se_ResetAuthorizersCacheCommand = async (input, context) => {
|
|
1186
|
-
const
|
|
752
|
+
const b = rb(input, context);
|
|
1187
753
|
const headers = {};
|
|
1188
|
-
|
|
1189
|
-
|
|
1190
|
-
|
|
1191
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "StageName", () => input.StageName, "{StageName}", false);
|
|
754
|
+
b.bp("/v2/apis/{ApiId}/stages/{StageName}/cache/authorizers");
|
|
755
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
756
|
+
b.p("StageName", () => input.StageName, "{StageName}", false);
|
|
1192
757
|
let body;
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
hostname,
|
|
1196
|
-
port,
|
|
1197
|
-
method: "DELETE",
|
|
1198
|
-
headers,
|
|
1199
|
-
path: resolvedPath,
|
|
1200
|
-
body,
|
|
1201
|
-
});
|
|
758
|
+
b.m("DELETE").h(headers).b(body);
|
|
759
|
+
return b.build();
|
|
1202
760
|
};
|
|
1203
761
|
export const se_TagResourceCommand = async (input, context) => {
|
|
1204
|
-
const
|
|
762
|
+
const b = rb(input, context);
|
|
1205
763
|
const headers = {
|
|
1206
764
|
"content-type": "application/json",
|
|
1207
765
|
};
|
|
1208
|
-
|
|
1209
|
-
|
|
766
|
+
b.bp("/v2/tags/{ResourceArn}");
|
|
767
|
+
b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
|
|
1210
768
|
let body;
|
|
1211
769
|
body = JSON.stringify(take(input, {
|
|
1212
770
|
tags: [, (_) => _json(_), `Tags`],
|
|
1213
771
|
}));
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
hostname,
|
|
1217
|
-
port,
|
|
1218
|
-
method: "POST",
|
|
1219
|
-
headers,
|
|
1220
|
-
path: resolvedPath,
|
|
1221
|
-
body,
|
|
1222
|
-
});
|
|
772
|
+
b.m("POST").h(headers).b(body);
|
|
773
|
+
return b.build();
|
|
1223
774
|
};
|
|
1224
775
|
export const se_UntagResourceCommand = async (input, context) => {
|
|
1225
|
-
const
|
|
776
|
+
const b = rb(input, context);
|
|
1226
777
|
const headers = {};
|
|
1227
|
-
|
|
1228
|
-
|
|
778
|
+
b.bp("/v2/tags/{ResourceArn}");
|
|
779
|
+
b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
|
|
1229
780
|
const query = map({
|
|
1230
|
-
|
|
781
|
+
[_tK]: [
|
|
1231
782
|
__expectNonNull(input.TagKeys, `TagKeys`) != null,
|
|
1232
|
-
() => (input
|
|
783
|
+
() => (input[_TK] || []).map((_entry) => _entry),
|
|
1233
784
|
],
|
|
1234
785
|
});
|
|
1235
786
|
let body;
|
|
1236
|
-
|
|
1237
|
-
|
|
1238
|
-
hostname,
|
|
1239
|
-
port,
|
|
1240
|
-
method: "DELETE",
|
|
1241
|
-
headers,
|
|
1242
|
-
path: resolvedPath,
|
|
1243
|
-
query,
|
|
1244
|
-
body,
|
|
1245
|
-
});
|
|
787
|
+
b.m("DELETE").h(headers).q(query).b(body);
|
|
788
|
+
return b.build();
|
|
1246
789
|
};
|
|
1247
790
|
export const se_UpdateApiCommand = async (input, context) => {
|
|
1248
|
-
const
|
|
791
|
+
const b = rb(input, context);
|
|
1249
792
|
const headers = {
|
|
1250
793
|
"content-type": "application/json",
|
|
1251
794
|
};
|
|
1252
|
-
|
|
1253
|
-
|
|
795
|
+
b.bp("/v2/apis/{ApiId}");
|
|
796
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
1254
797
|
let body;
|
|
1255
798
|
body = JSON.stringify(take(input, {
|
|
1256
799
|
apiKeySelectionExpression: [, , `ApiKeySelectionExpression`],
|
|
@@ -1265,50 +808,34 @@ export const se_UpdateApiCommand = async (input, context) => {
|
|
|
1265
808
|
target: [, , `Target`],
|
|
1266
809
|
version: [, , `Version`],
|
|
1267
810
|
}));
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
hostname,
|
|
1271
|
-
port,
|
|
1272
|
-
method: "PATCH",
|
|
1273
|
-
headers,
|
|
1274
|
-
path: resolvedPath,
|
|
1275
|
-
body,
|
|
1276
|
-
});
|
|
811
|
+
b.m("PATCH").h(headers).b(body);
|
|
812
|
+
return b.build();
|
|
1277
813
|
};
|
|
1278
814
|
export const se_UpdateApiMappingCommand = async (input, context) => {
|
|
1279
|
-
const
|
|
815
|
+
const b = rb(input, context);
|
|
1280
816
|
const headers = {
|
|
1281
817
|
"content-type": "application/json",
|
|
1282
818
|
};
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DomainName", () => input.DomainName, "{DomainName}", false);
|
|
819
|
+
b.bp("/v2/domainnames/{DomainName}/apimappings/{ApiMappingId}");
|
|
820
|
+
b.p("ApiMappingId", () => input.ApiMappingId, "{ApiMappingId}", false);
|
|
821
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1287
822
|
let body;
|
|
1288
823
|
body = JSON.stringify(take(input, {
|
|
1289
824
|
apiId: [, , `ApiId`],
|
|
1290
825
|
apiMappingKey: [, , `ApiMappingKey`],
|
|
1291
826
|
stage: [, , `Stage`],
|
|
1292
827
|
}));
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
hostname,
|
|
1296
|
-
port,
|
|
1297
|
-
method: "PATCH",
|
|
1298
|
-
headers,
|
|
1299
|
-
path: resolvedPath,
|
|
1300
|
-
body,
|
|
1301
|
-
});
|
|
828
|
+
b.m("PATCH").h(headers).b(body);
|
|
829
|
+
return b.build();
|
|
1302
830
|
};
|
|
1303
831
|
export const se_UpdateAuthorizerCommand = async (input, context) => {
|
|
1304
|
-
const
|
|
832
|
+
const b = rb(input, context);
|
|
1305
833
|
const headers = {
|
|
1306
834
|
"content-type": "application/json",
|
|
1307
835
|
};
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "AuthorizerId", () => input.AuthorizerId, "{AuthorizerId}", false);
|
|
836
|
+
b.bp("/v2/apis/{ApiId}/authorizers/{AuthorizerId}");
|
|
837
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
838
|
+
b.p("AuthorizerId", () => input.AuthorizerId, "{AuthorizerId}", false);
|
|
1312
839
|
let body;
|
|
1313
840
|
body = JSON.stringify(take(input, {
|
|
1314
841
|
authorizerCredentialsArn: [, , `AuthorizerCredentialsArn`],
|
|
@@ -1322,70 +849,47 @@ export const se_UpdateAuthorizerCommand = async (input, context) => {
|
|
|
1322
849
|
jwtConfiguration: [, (_) => se_JWTConfiguration(_, context), `JwtConfiguration`],
|
|
1323
850
|
name: [, , `Name`],
|
|
1324
851
|
}));
|
|
1325
|
-
|
|
1326
|
-
|
|
1327
|
-
hostname,
|
|
1328
|
-
port,
|
|
1329
|
-
method: "PATCH",
|
|
1330
|
-
headers,
|
|
1331
|
-
path: resolvedPath,
|
|
1332
|
-
body,
|
|
1333
|
-
});
|
|
852
|
+
b.m("PATCH").h(headers).b(body);
|
|
853
|
+
return b.build();
|
|
1334
854
|
};
|
|
1335
855
|
export const se_UpdateDeploymentCommand = async (input, context) => {
|
|
1336
|
-
const
|
|
856
|
+
const b = rb(input, context);
|
|
1337
857
|
const headers = {
|
|
1338
858
|
"content-type": "application/json",
|
|
1339
859
|
};
|
|
1340
|
-
|
|
1341
|
-
|
|
1342
|
-
|
|
1343
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
|
|
860
|
+
b.bp("/v2/apis/{ApiId}/deployments/{DeploymentId}");
|
|
861
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
862
|
+
b.p("DeploymentId", () => input.DeploymentId, "{DeploymentId}", false);
|
|
1344
863
|
let body;
|
|
1345
864
|
body = JSON.stringify(take(input, {
|
|
1346
865
|
description: [, , `Description`],
|
|
1347
866
|
}));
|
|
1348
|
-
|
|
1349
|
-
|
|
1350
|
-
hostname,
|
|
1351
|
-
port,
|
|
1352
|
-
method: "PATCH",
|
|
1353
|
-
headers,
|
|
1354
|
-
path: resolvedPath,
|
|
1355
|
-
body,
|
|
1356
|
-
});
|
|
867
|
+
b.m("PATCH").h(headers).b(body);
|
|
868
|
+
return b.build();
|
|
1357
869
|
};
|
|
1358
870
|
export const se_UpdateDomainNameCommand = async (input, context) => {
|
|
1359
|
-
const
|
|
871
|
+
const b = rb(input, context);
|
|
1360
872
|
const headers = {
|
|
1361
873
|
"content-type": "application/json",
|
|
1362
874
|
};
|
|
1363
|
-
|
|
1364
|
-
|
|
875
|
+
b.bp("/v2/domainnames/{DomainName}");
|
|
876
|
+
b.p("DomainName", () => input.DomainName, "{DomainName}", false);
|
|
1365
877
|
let body;
|
|
1366
878
|
body = JSON.stringify(take(input, {
|
|
1367
879
|
domainNameConfigurations: [, (_) => se_DomainNameConfigurations(_, context), `DomainNameConfigurations`],
|
|
1368
880
|
mutualTlsAuthentication: [, (_) => se_MutualTlsAuthenticationInput(_, context), `MutualTlsAuthentication`],
|
|
1369
881
|
}));
|
|
1370
|
-
|
|
1371
|
-
|
|
1372
|
-
hostname,
|
|
1373
|
-
port,
|
|
1374
|
-
method: "PATCH",
|
|
1375
|
-
headers,
|
|
1376
|
-
path: resolvedPath,
|
|
1377
|
-
body,
|
|
1378
|
-
});
|
|
882
|
+
b.m("PATCH").h(headers).b(body);
|
|
883
|
+
return b.build();
|
|
1379
884
|
};
|
|
1380
885
|
export const se_UpdateIntegrationCommand = async (input, context) => {
|
|
1381
|
-
const
|
|
886
|
+
const b = rb(input, context);
|
|
1382
887
|
const headers = {
|
|
1383
888
|
"content-type": "application/json",
|
|
1384
889
|
};
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
890
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}");
|
|
891
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
892
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
1389
893
|
let body;
|
|
1390
894
|
body = JSON.stringify(take(input, {
|
|
1391
895
|
connectionId: [, , `ConnectionId`],
|
|
@@ -1406,26 +910,18 @@ export const se_UpdateIntegrationCommand = async (input, context) => {
|
|
|
1406
910
|
timeoutInMillis: [, , `TimeoutInMillis`],
|
|
1407
911
|
tlsConfig: [, (_) => se_TlsConfigInput(_, context), `TlsConfig`],
|
|
1408
912
|
}));
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
hostname,
|
|
1412
|
-
port,
|
|
1413
|
-
method: "PATCH",
|
|
1414
|
-
headers,
|
|
1415
|
-
path: resolvedPath,
|
|
1416
|
-
body,
|
|
1417
|
-
});
|
|
913
|
+
b.m("PATCH").h(headers).b(body);
|
|
914
|
+
return b.build();
|
|
1418
915
|
};
|
|
1419
916
|
export const se_UpdateIntegrationResponseCommand = async (input, context) => {
|
|
1420
|
-
const
|
|
917
|
+
const b = rb(input, context);
|
|
1421
918
|
const headers = {
|
|
1422
919
|
"content-type": "application/json",
|
|
1423
920
|
};
|
|
1424
|
-
|
|
1425
|
-
|
|
1426
|
-
|
|
1427
|
-
|
|
1428
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "IntegrationResponseId", () => input.IntegrationResponseId, "{IntegrationResponseId}", false);
|
|
921
|
+
b.bp("/v2/apis/{ApiId}/integrations/{IntegrationId}/integrationresponses/{IntegrationResponseId}");
|
|
922
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
923
|
+
b.p("IntegrationId", () => input.IntegrationId, "{IntegrationId}", false);
|
|
924
|
+
b.p("IntegrationResponseId", () => input.IntegrationResponseId, "{IntegrationResponseId}", false);
|
|
1429
925
|
let body;
|
|
1430
926
|
body = JSON.stringify(take(input, {
|
|
1431
927
|
contentHandlingStrategy: [, , `ContentHandlingStrategy`],
|
|
@@ -1434,24 +930,17 @@ export const se_UpdateIntegrationResponseCommand = async (input, context) => {
|
|
|
1434
930
|
responseTemplates: [, (_) => _json(_), `ResponseTemplates`],
|
|
1435
931
|
templateSelectionExpression: [, , `TemplateSelectionExpression`],
|
|
1436
932
|
}));
|
|
1437
|
-
|
|
1438
|
-
|
|
1439
|
-
hostname,
|
|
1440
|
-
port,
|
|
1441
|
-
method: "PATCH",
|
|
1442
|
-
headers,
|
|
1443
|
-
path: resolvedPath,
|
|
1444
|
-
body,
|
|
1445
|
-
});
|
|
933
|
+
b.m("PATCH").h(headers).b(body);
|
|
934
|
+
return b.build();
|
|
1446
935
|
};
|
|
1447
936
|
export const se_UpdateModelCommand = async (input, context) => {
|
|
1448
|
-
const
|
|
937
|
+
const b = rb(input, context);
|
|
1449
938
|
const headers = {
|
|
1450
939
|
"content-type": "application/json",
|
|
1451
940
|
};
|
|
1452
|
-
|
|
1453
|
-
|
|
1454
|
-
|
|
941
|
+
b.bp("/v2/apis/{ApiId}/models/{ModelId}");
|
|
942
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
943
|
+
b.p("ModelId", () => input.ModelId, "{ModelId}", false);
|
|
1455
944
|
let body;
|
|
1456
945
|
body = JSON.stringify(take(input, {
|
|
1457
946
|
contentType: [, , `ContentType`],
|
|
@@ -1459,24 +948,17 @@ export const se_UpdateModelCommand = async (input, context) => {
|
|
|
1459
948
|
name: [, , `Name`],
|
|
1460
949
|
schema: [, , `Schema`],
|
|
1461
950
|
}));
|
|
1462
|
-
|
|
1463
|
-
|
|
1464
|
-
hostname,
|
|
1465
|
-
port,
|
|
1466
|
-
method: "PATCH",
|
|
1467
|
-
headers,
|
|
1468
|
-
path: resolvedPath,
|
|
1469
|
-
body,
|
|
1470
|
-
});
|
|
951
|
+
b.m("PATCH").h(headers).b(body);
|
|
952
|
+
return b.build();
|
|
1471
953
|
};
|
|
1472
954
|
export const se_UpdateRouteCommand = async (input, context) => {
|
|
1473
|
-
const
|
|
955
|
+
const b = rb(input, context);
|
|
1474
956
|
const headers = {
|
|
1475
957
|
"content-type": "application/json",
|
|
1476
958
|
};
|
|
1477
|
-
|
|
1478
|
-
|
|
1479
|
-
|
|
959
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}");
|
|
960
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
961
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
1480
962
|
let body;
|
|
1481
963
|
body = JSON.stringify(take(input, {
|
|
1482
964
|
apiKeyRequired: [, , `ApiKeyRequired`],
|
|
@@ -1491,26 +973,18 @@ export const se_UpdateRouteCommand = async (input, context) => {
|
|
|
1491
973
|
routeResponseSelectionExpression: [, , `RouteResponseSelectionExpression`],
|
|
1492
974
|
target: [, , `Target`],
|
|
1493
975
|
}));
|
|
1494
|
-
|
|
1495
|
-
|
|
1496
|
-
hostname,
|
|
1497
|
-
port,
|
|
1498
|
-
method: "PATCH",
|
|
1499
|
-
headers,
|
|
1500
|
-
path: resolvedPath,
|
|
1501
|
-
body,
|
|
1502
|
-
});
|
|
976
|
+
b.m("PATCH").h(headers).b(body);
|
|
977
|
+
return b.build();
|
|
1503
978
|
};
|
|
1504
979
|
export const se_UpdateRouteResponseCommand = async (input, context) => {
|
|
1505
|
-
const
|
|
980
|
+
const b = rb(input, context);
|
|
1506
981
|
const headers = {
|
|
1507
982
|
"content-type": "application/json",
|
|
1508
983
|
};
|
|
1509
|
-
|
|
1510
|
-
|
|
1511
|
-
|
|
1512
|
-
|
|
1513
|
-
resolvedPath = __resolvedPath(resolvedPath, input, "RouteResponseId", () => input.RouteResponseId, "{RouteResponseId}", false);
|
|
984
|
+
b.bp("/v2/apis/{ApiId}/routes/{RouteId}/routeresponses/{RouteResponseId}");
|
|
985
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
986
|
+
b.p("RouteId", () => input.RouteId, "{RouteId}", false);
|
|
987
|
+
b.p("RouteResponseId", () => input.RouteResponseId, "{RouteResponseId}", false);
|
|
1514
988
|
let body;
|
|
1515
989
|
body = JSON.stringify(take(input, {
|
|
1516
990
|
modelSelectionExpression: [, , `ModelSelectionExpression`],
|
|
@@ -1518,24 +992,17 @@ export const se_UpdateRouteResponseCommand = async (input, context) => {
|
|
|
1518
992
|
responseParameters: [, (_) => se_RouteParameters(_, context), `ResponseParameters`],
|
|
1519
993
|
routeResponseKey: [, , `RouteResponseKey`],
|
|
1520
994
|
}));
|
|
1521
|
-
|
|
1522
|
-
|
|
1523
|
-
hostname,
|
|
1524
|
-
port,
|
|
1525
|
-
method: "PATCH",
|
|
1526
|
-
headers,
|
|
1527
|
-
path: resolvedPath,
|
|
1528
|
-
body,
|
|
1529
|
-
});
|
|
995
|
+
b.m("PATCH").h(headers).b(body);
|
|
996
|
+
return b.build();
|
|
1530
997
|
};
|
|
1531
998
|
export const se_UpdateStageCommand = async (input, context) => {
|
|
1532
|
-
const
|
|
999
|
+
const b = rb(input, context);
|
|
1533
1000
|
const headers = {
|
|
1534
1001
|
"content-type": "application/json",
|
|
1535
1002
|
};
|
|
1536
|
-
|
|
1537
|
-
|
|
1538
|
-
|
|
1003
|
+
b.bp("/v2/apis/{ApiId}/stages/{StageName}");
|
|
1004
|
+
b.p("ApiId", () => input.ApiId, "{ApiId}", false);
|
|
1005
|
+
b.p("StageName", () => input.StageName, "{StageName}", false);
|
|
1539
1006
|
let body;
|
|
1540
1007
|
body = JSON.stringify(take(input, {
|
|
1541
1008
|
accessLogSettings: [, (_) => se_AccessLogSettings(_, context), `AccessLogSettings`],
|
|
@@ -1547,36 +1014,22 @@ export const se_UpdateStageCommand = async (input, context) => {
|
|
|
1547
1014
|
routeSettings: [, (_) => se_RouteSettingsMap(_, context), `RouteSettings`],
|
|
1548
1015
|
stageVariables: [, (_) => _json(_), `StageVariables`],
|
|
1549
1016
|
}));
|
|
1550
|
-
|
|
1551
|
-
|
|
1552
|
-
hostname,
|
|
1553
|
-
port,
|
|
1554
|
-
method: "PATCH",
|
|
1555
|
-
headers,
|
|
1556
|
-
path: resolvedPath,
|
|
1557
|
-
body,
|
|
1558
|
-
});
|
|
1017
|
+
b.m("PATCH").h(headers).b(body);
|
|
1018
|
+
return b.build();
|
|
1559
1019
|
};
|
|
1560
1020
|
export const se_UpdateVpcLinkCommand = async (input, context) => {
|
|
1561
|
-
const
|
|
1021
|
+
const b = rb(input, context);
|
|
1562
1022
|
const headers = {
|
|
1563
1023
|
"content-type": "application/json",
|
|
1564
1024
|
};
|
|
1565
|
-
|
|
1566
|
-
|
|
1025
|
+
b.bp("/v2/vpclinks/{VpcLinkId}");
|
|
1026
|
+
b.p("VpcLinkId", () => input.VpcLinkId, "{VpcLinkId}", false);
|
|
1567
1027
|
let body;
|
|
1568
1028
|
body = JSON.stringify(take(input, {
|
|
1569
1029
|
name: [, , `Name`],
|
|
1570
1030
|
}));
|
|
1571
|
-
|
|
1572
|
-
|
|
1573
|
-
hostname,
|
|
1574
|
-
port,
|
|
1575
|
-
method: "PATCH",
|
|
1576
|
-
headers,
|
|
1577
|
-
path: resolvedPath,
|
|
1578
|
-
body,
|
|
1579
|
-
});
|
|
1031
|
+
b.m("PATCH").h(headers).b(body);
|
|
1032
|
+
return b.build();
|
|
1580
1033
|
};
|
|
1581
1034
|
export const de_CreateApiCommand = async (output, context) => {
|
|
1582
1035
|
if (output.statusCode !== 201 && output.statusCode >= 300) {
|
|
@@ -5165,6 +4618,24 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
|
|
|
5165
4618
|
value !== "" &&
|
|
5166
4619
|
(!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
|
|
5167
4620
|
(!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
|
|
4621
|
+
const _B = "Basepath";
|
|
4622
|
+
const _EV = "ExportVersion";
|
|
4623
|
+
const _FOW = "FailOnWarnings";
|
|
4624
|
+
const _IE = "IncludeExtensions";
|
|
4625
|
+
const _MR = "MaxResults";
|
|
4626
|
+
const _NT = "NextToken";
|
|
4627
|
+
const _OT = "OutputType";
|
|
4628
|
+
const _SN = "StageName";
|
|
4629
|
+
const _TK = "TagKeys";
|
|
4630
|
+
const _b = "basepath";
|
|
4631
|
+
const _eV = "exportVersion";
|
|
4632
|
+
const _fOW = "failOnWarnings";
|
|
4633
|
+
const _iE = "includeExtensions";
|
|
4634
|
+
const _mR = "maxResults";
|
|
4635
|
+
const _nT = "nextToken";
|
|
4636
|
+
const _oT = "outputType";
|
|
4637
|
+
const _sN = "stageName";
|
|
4638
|
+
const _tK = "tagKeys";
|
|
5168
4639
|
const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
|
|
5169
4640
|
if (encoded.length) {
|
|
5170
4641
|
return JSON.parse(encoded);
|