@aws-sdk/client-proton 3.309.0 → 3.312.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.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_json1_0.js +90 -336
  2. package/dist-es/protocols/Aws_json1_0.js +90 -336
  3. package/package.json +36 -36
package/dist-cjs/protocols/Aws_json1_0.js CHANGED
@@ -10,840 +10,588 @@ const uuid_1 = require("uuid");
10
10
  const models_0_1 = require("../models/models_0");
11
11
  const ProtonServiceException_1 = require("../models/ProtonServiceException");
12
12
  const se_AcceptEnvironmentAccountConnectionCommand = async (input, context) => {
13
- const headers = {
14
- "content-type": "application/x-amz-json-1.0",
15
- "x-amz-target": "AwsProton20200720.AcceptEnvironmentAccountConnection",
16
- };
13
+ const headers = sharedHeaders("AcceptEnvironmentAccountConnection");
17
14
  let body;
18
15
  body = JSON.stringify(se_AcceptEnvironmentAccountConnectionInput(input, context));
19
16
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
20
17
  };
21
18
  exports.se_AcceptEnvironmentAccountConnectionCommand = se_AcceptEnvironmentAccountConnectionCommand;
22
19
  const se_CancelComponentDeploymentCommand = async (input, context) => {
23
- const headers = {
24
- "content-type": "application/x-amz-json-1.0",
25
- "x-amz-target": "AwsProton20200720.CancelComponentDeployment",
26
- };
20
+ const headers = sharedHeaders("CancelComponentDeployment");
27
21
  let body;
28
22
  body = JSON.stringify(se_CancelComponentDeploymentInput(input, context));
29
23
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
30
24
  };
31
25
  exports.se_CancelComponentDeploymentCommand = se_CancelComponentDeploymentCommand;
32
26
  const se_CancelEnvironmentDeploymentCommand = async (input, context) => {
33
- const headers = {
34
- "content-type": "application/x-amz-json-1.0",
35
- "x-amz-target": "AwsProton20200720.CancelEnvironmentDeployment",
36
- };
27
+ const headers = sharedHeaders("CancelEnvironmentDeployment");
37
28
  let body;
38
29
  body = JSON.stringify(se_CancelEnvironmentDeploymentInput(input, context));
39
30
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
40
31
  };
41
32
  exports.se_CancelEnvironmentDeploymentCommand = se_CancelEnvironmentDeploymentCommand;
42
33
  const se_CancelServiceInstanceDeploymentCommand = async (input, context) => {
43
- const headers = {
44
- "content-type": "application/x-amz-json-1.0",
45
- "x-amz-target": "AwsProton20200720.CancelServiceInstanceDeployment",
46
- };
34
+ const headers = sharedHeaders("CancelServiceInstanceDeployment");
47
35
  let body;
48
36
  body = JSON.stringify(se_CancelServiceInstanceDeploymentInput(input, context));
49
37
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
50
38
  };
51
39
  exports.se_CancelServiceInstanceDeploymentCommand = se_CancelServiceInstanceDeploymentCommand;
52
40
  const se_CancelServicePipelineDeploymentCommand = async (input, context) => {
53
- const headers = {
54
- "content-type": "application/x-amz-json-1.0",
55
- "x-amz-target": "AwsProton20200720.CancelServicePipelineDeployment",
56
- };
41
+ const headers = sharedHeaders("CancelServicePipelineDeployment");
57
42
  let body;
58
43
  body = JSON.stringify(se_CancelServicePipelineDeploymentInput(input, context));
59
44
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
60
45
  };
61
46
  exports.se_CancelServicePipelineDeploymentCommand = se_CancelServicePipelineDeploymentCommand;
62
47
  const se_CreateComponentCommand = async (input, context) => {
63
- const headers = {
64
- "content-type": "application/x-amz-json-1.0",
65
- "x-amz-target": "AwsProton20200720.CreateComponent",
66
- };
48
+ const headers = sharedHeaders("CreateComponent");
67
49
  let body;
68
50
  body = JSON.stringify(se_CreateComponentInput(input, context));
69
51
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
70
52
  };
71
53
  exports.se_CreateComponentCommand = se_CreateComponentCommand;
72
54
  const se_CreateEnvironmentCommand = async (input, context) => {
73
- const headers = {
74
- "content-type": "application/x-amz-json-1.0",
75
- "x-amz-target": "AwsProton20200720.CreateEnvironment",
76
- };
55
+ const headers = sharedHeaders("CreateEnvironment");
77
56
  let body;
78
57
  body = JSON.stringify(se_CreateEnvironmentInput(input, context));
79
58
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
80
59
  };
81
60
  exports.se_CreateEnvironmentCommand = se_CreateEnvironmentCommand;
82
61
  const se_CreateEnvironmentAccountConnectionCommand = async (input, context) => {
83
- const headers = {
84
- "content-type": "application/x-amz-json-1.0",
85
- "x-amz-target": "AwsProton20200720.CreateEnvironmentAccountConnection",
86
- };
62
+ const headers = sharedHeaders("CreateEnvironmentAccountConnection");
87
63
  let body;
88
64
  body = JSON.stringify(se_CreateEnvironmentAccountConnectionInput(input, context));
89
65
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
90
66
  };
91
67
  exports.se_CreateEnvironmentAccountConnectionCommand = se_CreateEnvironmentAccountConnectionCommand;
92
68
  const se_CreateEnvironmentTemplateCommand = async (input, context) => {
93
- const headers = {
94
- "content-type": "application/x-amz-json-1.0",
95
- "x-amz-target": "AwsProton20200720.CreateEnvironmentTemplate",
96
- };
69
+ const headers = sharedHeaders("CreateEnvironmentTemplate");
97
70
  let body;
98
71
  body = JSON.stringify(se_CreateEnvironmentTemplateInput(input, context));
99
72
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
100
73
  };
101
74
  exports.se_CreateEnvironmentTemplateCommand = se_CreateEnvironmentTemplateCommand;
102
75
  const se_CreateEnvironmentTemplateVersionCommand = async (input, context) => {
103
- const headers = {
104
- "content-type": "application/x-amz-json-1.0",
105
- "x-amz-target": "AwsProton20200720.CreateEnvironmentTemplateVersion",
106
- };
76
+ const headers = sharedHeaders("CreateEnvironmentTemplateVersion");
107
77
  let body;
108
78
  body = JSON.stringify(se_CreateEnvironmentTemplateVersionInput(input, context));
109
79
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
110
80
  };
111
81
  exports.se_CreateEnvironmentTemplateVersionCommand = se_CreateEnvironmentTemplateVersionCommand;
112
82
  const se_CreateRepositoryCommand = async (input, context) => {
113
- const headers = {
114
- "content-type": "application/x-amz-json-1.0",
115
- "x-amz-target": "AwsProton20200720.CreateRepository",
116
- };
83
+ const headers = sharedHeaders("CreateRepository");
117
84
  let body;
118
85
  body = JSON.stringify(se_CreateRepositoryInput(input, context));
119
86
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
120
87
  };
121
88
  exports.se_CreateRepositoryCommand = se_CreateRepositoryCommand;
122
89
  const se_CreateServiceCommand = async (input, context) => {
123
- const headers = {
124
- "content-type": "application/x-amz-json-1.0",
125
- "x-amz-target": "AwsProton20200720.CreateService",
126
- };
90
+ const headers = sharedHeaders("CreateService");
127
91
  let body;
128
92
  body = JSON.stringify(se_CreateServiceInput(input, context));
129
93
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
130
94
  };
131
95
  exports.se_CreateServiceCommand = se_CreateServiceCommand;
132
96
  const se_CreateServiceInstanceCommand = async (input, context) => {
133
- const headers = {
134
- "content-type": "application/x-amz-json-1.0",
135
- "x-amz-target": "AwsProton20200720.CreateServiceInstance",
136
- };
97
+ const headers = sharedHeaders("CreateServiceInstance");
137
98
  let body;
138
99
  body = JSON.stringify(se_CreateServiceInstanceInput(input, context));
139
100
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
140
101
  };
141
102
  exports.se_CreateServiceInstanceCommand = se_CreateServiceInstanceCommand;
142
103
  const se_CreateServiceSyncConfigCommand = async (input, context) => {
143
- const headers = {
144
- "content-type": "application/x-amz-json-1.0",
145
- "x-amz-target": "AwsProton20200720.CreateServiceSyncConfig",
146
- };
104
+ const headers = sharedHeaders("CreateServiceSyncConfig");
147
105
  let body;
148
106
  body = JSON.stringify(se_CreateServiceSyncConfigInput(input, context));
149
107
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
150
108
  };
151
109
  exports.se_CreateServiceSyncConfigCommand = se_CreateServiceSyncConfigCommand;
152
110
  const se_CreateServiceTemplateCommand = async (input, context) => {
153
- const headers = {
154
- "content-type": "application/x-amz-json-1.0",
155
- "x-amz-target": "AwsProton20200720.CreateServiceTemplate",
156
- };
111
+ const headers = sharedHeaders("CreateServiceTemplate");
157
112
  let body;
158
113
  body = JSON.stringify(se_CreateServiceTemplateInput(input, context));
159
114
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
160
115
  };
161
116
  exports.se_CreateServiceTemplateCommand = se_CreateServiceTemplateCommand;
162
117
  const se_CreateServiceTemplateVersionCommand = async (input, context) => {
163
- const headers = {
164
- "content-type": "application/x-amz-json-1.0",
165
- "x-amz-target": "AwsProton20200720.CreateServiceTemplateVersion",
166
- };
118
+ const headers = sharedHeaders("CreateServiceTemplateVersion");
167
119
  let body;
168
120
  body = JSON.stringify(se_CreateServiceTemplateVersionInput(input, context));
169
121
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
170
122
  };
171
123
  exports.se_CreateServiceTemplateVersionCommand = se_CreateServiceTemplateVersionCommand;
172
124
  const se_CreateTemplateSyncConfigCommand = async (input, context) => {
173
- const headers = {
174
- "content-type": "application/x-amz-json-1.0",
175
- "x-amz-target": "AwsProton20200720.CreateTemplateSyncConfig",
176
- };
125
+ const headers = sharedHeaders("CreateTemplateSyncConfig");
177
126
  let body;
178
127
  body = JSON.stringify(se_CreateTemplateSyncConfigInput(input, context));
179
128
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
180
129
  };
181
130
  exports.se_CreateTemplateSyncConfigCommand = se_CreateTemplateSyncConfigCommand;
182
131
  const se_DeleteComponentCommand = async (input, context) => {
183
- const headers = {
184
- "content-type": "application/x-amz-json-1.0",
185
- "x-amz-target": "AwsProton20200720.DeleteComponent",
186
- };
132
+ const headers = sharedHeaders("DeleteComponent");
187
133
  let body;
188
134
  body = JSON.stringify(se_DeleteComponentInput(input, context));
189
135
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
190
136
  };
191
137
  exports.se_DeleteComponentCommand = se_DeleteComponentCommand;
192
138
  const se_DeleteEnvironmentCommand = async (input, context) => {
193
- const headers = {
194
- "content-type": "application/x-amz-json-1.0",
195
- "x-amz-target": "AwsProton20200720.DeleteEnvironment",
196
- };
139
+ const headers = sharedHeaders("DeleteEnvironment");
197
140
  let body;
198
141
  body = JSON.stringify(se_DeleteEnvironmentInput(input, context));
199
142
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
200
143
  };
201
144
  exports.se_DeleteEnvironmentCommand = se_DeleteEnvironmentCommand;
202
145
  const se_DeleteEnvironmentAccountConnectionCommand = async (input, context) => {
203
- const headers = {
204
- "content-type": "application/x-amz-json-1.0",
205
- "x-amz-target": "AwsProton20200720.DeleteEnvironmentAccountConnection",
206
- };
146
+ const headers = sharedHeaders("DeleteEnvironmentAccountConnection");
207
147
  let body;
208
148
  body = JSON.stringify(se_DeleteEnvironmentAccountConnectionInput(input, context));
209
149
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
210
150
  };
211
151
  exports.se_DeleteEnvironmentAccountConnectionCommand = se_DeleteEnvironmentAccountConnectionCommand;
212
152
  const se_DeleteEnvironmentTemplateCommand = async (input, context) => {
213
- const headers = {
214
- "content-type": "application/x-amz-json-1.0",
215
- "x-amz-target": "AwsProton20200720.DeleteEnvironmentTemplate",
216
- };
153
+ const headers = sharedHeaders("DeleteEnvironmentTemplate");
217
154
  let body;
218
155
  body = JSON.stringify(se_DeleteEnvironmentTemplateInput(input, context));
219
156
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
220
157
  };
221
158
  exports.se_DeleteEnvironmentTemplateCommand = se_DeleteEnvironmentTemplateCommand;
222
159
  const se_DeleteEnvironmentTemplateVersionCommand = async (input, context) => {
223
- const headers = {
224
- "content-type": "application/x-amz-json-1.0",
225
- "x-amz-target": "AwsProton20200720.DeleteEnvironmentTemplateVersion",
226
- };
160
+ const headers = sharedHeaders("DeleteEnvironmentTemplateVersion");
227
161
  let body;
228
162
  body = JSON.stringify(se_DeleteEnvironmentTemplateVersionInput(input, context));
229
163
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
230
164
  };
231
165
  exports.se_DeleteEnvironmentTemplateVersionCommand = se_DeleteEnvironmentTemplateVersionCommand;
232
166
  const se_DeleteRepositoryCommand = async (input, context) => {
233
- const headers = {
234
- "content-type": "application/x-amz-json-1.0",
235
- "x-amz-target": "AwsProton20200720.DeleteRepository",
236
- };
167
+ const headers = sharedHeaders("DeleteRepository");
237
168
  let body;
238
169
  body = JSON.stringify(se_DeleteRepositoryInput(input, context));
239
170
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
240
171
  };
241
172
  exports.se_DeleteRepositoryCommand = se_DeleteRepositoryCommand;
242
173
  const se_DeleteServiceCommand = async (input, context) => {
243
- const headers = {
244
- "content-type": "application/x-amz-json-1.0",
245
- "x-amz-target": "AwsProton20200720.DeleteService",
246
- };
174
+ const headers = sharedHeaders("DeleteService");
247
175
  let body;
248
176
  body = JSON.stringify(se_DeleteServiceInput(input, context));
249
177
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
250
178
  };
251
179
  exports.se_DeleteServiceCommand = se_DeleteServiceCommand;
252
180
  const se_DeleteServiceSyncConfigCommand = async (input, context) => {
253
- const headers = {
254
- "content-type": "application/x-amz-json-1.0",
255
- "x-amz-target": "AwsProton20200720.DeleteServiceSyncConfig",
256
- };
181
+ const headers = sharedHeaders("DeleteServiceSyncConfig");
257
182
  let body;
258
183
  body = JSON.stringify(se_DeleteServiceSyncConfigInput(input, context));
259
184
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
260
185
  };
261
186
  exports.se_DeleteServiceSyncConfigCommand = se_DeleteServiceSyncConfigCommand;
262
187
  const se_DeleteServiceTemplateCommand = async (input, context) => {
263
- const headers = {
264
- "content-type": "application/x-amz-json-1.0",
265
- "x-amz-target": "AwsProton20200720.DeleteServiceTemplate",
266
- };
188
+ const headers = sharedHeaders("DeleteServiceTemplate");
267
189
  let body;
268
190
  body = JSON.stringify(se_DeleteServiceTemplateInput(input, context));
269
191
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
270
192
  };
271
193
  exports.se_DeleteServiceTemplateCommand = se_DeleteServiceTemplateCommand;
272
194
  const se_DeleteServiceTemplateVersionCommand = async (input, context) => {
273
- const headers = {
274
- "content-type": "application/x-amz-json-1.0",
275
- "x-amz-target": "AwsProton20200720.DeleteServiceTemplateVersion",
276
- };
195
+ const headers = sharedHeaders("DeleteServiceTemplateVersion");
277
196
  let body;
278
197
  body = JSON.stringify(se_DeleteServiceTemplateVersionInput(input, context));
279
198
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
280
199
  };
281
200
  exports.se_DeleteServiceTemplateVersionCommand = se_DeleteServiceTemplateVersionCommand;
282
201
  const se_DeleteTemplateSyncConfigCommand = async (input, context) => {
283
- const headers = {
284
- "content-type": "application/x-amz-json-1.0",
285
- "x-amz-target": "AwsProton20200720.DeleteTemplateSyncConfig",
286
- };
202
+ const headers = sharedHeaders("DeleteTemplateSyncConfig");
287
203
  let body;
288
204
  body = JSON.stringify(se_DeleteTemplateSyncConfigInput(input, context));
289
205
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
290
206
  };
291
207
  exports.se_DeleteTemplateSyncConfigCommand = se_DeleteTemplateSyncConfigCommand;
292
208
  const se_GetAccountSettingsCommand = async (input, context) => {
293
- const headers = {
294
- "content-type": "application/x-amz-json-1.0",
295
- "x-amz-target": "AwsProton20200720.GetAccountSettings",
296
- };
209
+ const headers = sharedHeaders("GetAccountSettings");
297
210
  let body;
298
211
  body = JSON.stringify(se_GetAccountSettingsInput(input, context));
299
212
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
300
213
  };
301
214
  exports.se_GetAccountSettingsCommand = se_GetAccountSettingsCommand;
302
215
  const se_GetComponentCommand = async (input, context) => {
303
- const headers = {
304
- "content-type": "application/x-amz-json-1.0",
305
- "x-amz-target": "AwsProton20200720.GetComponent",
306
- };
216
+ const headers = sharedHeaders("GetComponent");
307
217
  let body;
308
218
  body = JSON.stringify(se_GetComponentInput(input, context));
309
219
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
310
220
  };
311
221
  exports.se_GetComponentCommand = se_GetComponentCommand;
312
222
  const se_GetEnvironmentCommand = async (input, context) => {
313
- const headers = {
314
- "content-type": "application/x-amz-json-1.0",
315
- "x-amz-target": "AwsProton20200720.GetEnvironment",
316
- };
223
+ const headers = sharedHeaders("GetEnvironment");
317
224
  let body;
318
225
  body = JSON.stringify(se_GetEnvironmentInput(input, context));
319
226
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
320
227
  };
321
228
  exports.se_GetEnvironmentCommand = se_GetEnvironmentCommand;
322
229
  const se_GetEnvironmentAccountConnectionCommand = async (input, context) => {
323
- const headers = {
324
- "content-type": "application/x-amz-json-1.0",
325
- "x-amz-target": "AwsProton20200720.GetEnvironmentAccountConnection",
326
- };
230
+ const headers = sharedHeaders("GetEnvironmentAccountConnection");
327
231
  let body;
328
232
  body = JSON.stringify(se_GetEnvironmentAccountConnectionInput(input, context));
329
233
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
330
234
  };
331
235
  exports.se_GetEnvironmentAccountConnectionCommand = se_GetEnvironmentAccountConnectionCommand;
332
236
  const se_GetEnvironmentTemplateCommand = async (input, context) => {
333
- const headers = {
334
- "content-type": "application/x-amz-json-1.0",
335
- "x-amz-target": "AwsProton20200720.GetEnvironmentTemplate",
336
- };
237
+ const headers = sharedHeaders("GetEnvironmentTemplate");
337
238
  let body;
338
239
  body = JSON.stringify(se_GetEnvironmentTemplateInput(input, context));
339
240
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
340
241
  };
341
242
  exports.se_GetEnvironmentTemplateCommand = se_GetEnvironmentTemplateCommand;
342
243
  const se_GetEnvironmentTemplateVersionCommand = async (input, context) => {
343
- const headers = {
344
- "content-type": "application/x-amz-json-1.0",
345
- "x-amz-target": "AwsProton20200720.GetEnvironmentTemplateVersion",
346
- };
244
+ const headers = sharedHeaders("GetEnvironmentTemplateVersion");
347
245
  let body;
348
246
  body = JSON.stringify(se_GetEnvironmentTemplateVersionInput(input, context));
349
247
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
350
248
  };
351
249
  exports.se_GetEnvironmentTemplateVersionCommand = se_GetEnvironmentTemplateVersionCommand;
352
250
  const se_GetRepositoryCommand = async (input, context) => {
353
- const headers = {
354
- "content-type": "application/x-amz-json-1.0",
355
- "x-amz-target": "AwsProton20200720.GetRepository",
356
- };
251
+ const headers = sharedHeaders("GetRepository");
357
252
  let body;
358
253
  body = JSON.stringify(se_GetRepositoryInput(input, context));
359
254
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
360
255
  };
361
256
  exports.se_GetRepositoryCommand = se_GetRepositoryCommand;
362
257
  const se_GetRepositorySyncStatusCommand = async (input, context) => {
363
- const headers = {
364
- "content-type": "application/x-amz-json-1.0",
365
- "x-amz-target": "AwsProton20200720.GetRepositorySyncStatus",
366
- };
258
+ const headers = sharedHeaders("GetRepositorySyncStatus");
367
259
  let body;
368
260
  body = JSON.stringify(se_GetRepositorySyncStatusInput(input, context));
369
261
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
370
262
  };
371
263
  exports.se_GetRepositorySyncStatusCommand = se_GetRepositorySyncStatusCommand;
372
264
  const se_GetResourcesSummaryCommand = async (input, context) => {
373
- const headers = {
374
- "content-type": "application/x-amz-json-1.0",
375
- "x-amz-target": "AwsProton20200720.GetResourcesSummary",
376
- };
265
+ const headers = sharedHeaders("GetResourcesSummary");
377
266
  let body;
378
267
  body = JSON.stringify(se_GetResourcesSummaryInput(input, context));
379
268
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
380
269
  };
381
270
  exports.se_GetResourcesSummaryCommand = se_GetResourcesSummaryCommand;
382
271
  const se_GetServiceCommand = async (input, context) => {
383
- const headers = {
384
- "content-type": "application/x-amz-json-1.0",
385
- "x-amz-target": "AwsProton20200720.GetService",
386
- };
272
+ const headers = sharedHeaders("GetService");
387
273
  let body;
388
274
  body = JSON.stringify(se_GetServiceInput(input, context));
389
275
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
390
276
  };
391
277
  exports.se_GetServiceCommand = se_GetServiceCommand;
392
278
  const se_GetServiceInstanceCommand = async (input, context) => {
393
- const headers = {
394
- "content-type": "application/x-amz-json-1.0",
395
- "x-amz-target": "AwsProton20200720.GetServiceInstance",
396
- };
279
+ const headers = sharedHeaders("GetServiceInstance");
397
280
  let body;
398
281
  body = JSON.stringify(se_GetServiceInstanceInput(input, context));
399
282
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
400
283
  };
401
284
  exports.se_GetServiceInstanceCommand = se_GetServiceInstanceCommand;
402
285
  const se_GetServiceInstanceSyncStatusCommand = async (input, context) => {
403
- const headers = {
404
- "content-type": "application/x-amz-json-1.0",
405
- "x-amz-target": "AwsProton20200720.GetServiceInstanceSyncStatus",
406
- };
286
+ const headers = sharedHeaders("GetServiceInstanceSyncStatus");
407
287
  let body;
408
288
  body = JSON.stringify(se_GetServiceInstanceSyncStatusInput(input, context));
409
289
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
410
290
  };
411
291
  exports.se_GetServiceInstanceSyncStatusCommand = se_GetServiceInstanceSyncStatusCommand;
412
292
  const se_GetServiceSyncBlockerSummaryCommand = async (input, context) => {
413
- const headers = {
414
- "content-type": "application/x-amz-json-1.0",
415
- "x-amz-target": "AwsProton20200720.GetServiceSyncBlockerSummary",
416
- };
293
+ const headers = sharedHeaders("GetServiceSyncBlockerSummary");
417
294
  let body;
418
295
  body = JSON.stringify(se_GetServiceSyncBlockerSummaryInput(input, context));
419
296
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
420
297
  };
421
298
  exports.se_GetServiceSyncBlockerSummaryCommand = se_GetServiceSyncBlockerSummaryCommand;
422
299
  const se_GetServiceSyncConfigCommand = async (input, context) => {
423
- const headers = {
424
- "content-type": "application/x-amz-json-1.0",
425
- "x-amz-target": "AwsProton20200720.GetServiceSyncConfig",
426
- };
300
+ const headers = sharedHeaders("GetServiceSyncConfig");
427
301
  let body;
428
302
  body = JSON.stringify(se_GetServiceSyncConfigInput(input, context));
429
303
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
430
304
  };
431
305
  exports.se_GetServiceSyncConfigCommand = se_GetServiceSyncConfigCommand;
432
306
  const se_GetServiceTemplateCommand = async (input, context) => {
433
- const headers = {
434
- "content-type": "application/x-amz-json-1.0",
435
- "x-amz-target": "AwsProton20200720.GetServiceTemplate",
436
- };
307
+ const headers = sharedHeaders("GetServiceTemplate");
437
308
  let body;
438
309
  body = JSON.stringify(se_GetServiceTemplateInput(input, context));
439
310
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
440
311
  };
441
312
  exports.se_GetServiceTemplateCommand = se_GetServiceTemplateCommand;
442
313
  const se_GetServiceTemplateVersionCommand = async (input, context) => {
443
- const headers = {
444
- "content-type": "application/x-amz-json-1.0",
445
- "x-amz-target": "AwsProton20200720.GetServiceTemplateVersion",
446
- };
314
+ const headers = sharedHeaders("GetServiceTemplateVersion");
447
315
  let body;
448
316
  body = JSON.stringify(se_GetServiceTemplateVersionInput(input, context));
449
317
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
450
318
  };
451
319
  exports.se_GetServiceTemplateVersionCommand = se_GetServiceTemplateVersionCommand;
452
320
  const se_GetTemplateSyncConfigCommand = async (input, context) => {
453
- const headers = {
454
- "content-type": "application/x-amz-json-1.0",
455
- "x-amz-target": "AwsProton20200720.GetTemplateSyncConfig",
456
- };
321
+ const headers = sharedHeaders("GetTemplateSyncConfig");
457
322
  let body;
458
323
  body = JSON.stringify(se_GetTemplateSyncConfigInput(input, context));
459
324
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
460
325
  };
461
326
  exports.se_GetTemplateSyncConfigCommand = se_GetTemplateSyncConfigCommand;
462
327
  const se_GetTemplateSyncStatusCommand = async (input, context) => {
463
- const headers = {
464
- "content-type": "application/x-amz-json-1.0",
465
- "x-amz-target": "AwsProton20200720.GetTemplateSyncStatus",
466
- };
328
+ const headers = sharedHeaders("GetTemplateSyncStatus");
467
329
  let body;
468
330
  body = JSON.stringify(se_GetTemplateSyncStatusInput(input, context));
469
331
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
470
332
  };
471
333
  exports.se_GetTemplateSyncStatusCommand = se_GetTemplateSyncStatusCommand;
472
334
  const se_ListComponentOutputsCommand = async (input, context) => {
473
- const headers = {
474
- "content-type": "application/x-amz-json-1.0",
475
- "x-amz-target": "AwsProton20200720.ListComponentOutputs",
476
- };
335
+ const headers = sharedHeaders("ListComponentOutputs");
477
336
  let body;
478
337
  body = JSON.stringify(se_ListComponentOutputsInput(input, context));
479
338
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
480
339
  };
481
340
  exports.se_ListComponentOutputsCommand = se_ListComponentOutputsCommand;
482
341
  const se_ListComponentProvisionedResourcesCommand = async (input, context) => {
483
- const headers = {
484
- "content-type": "application/x-amz-json-1.0",
485
- "x-amz-target": "AwsProton20200720.ListComponentProvisionedResources",
486
- };
342
+ const headers = sharedHeaders("ListComponentProvisionedResources");
487
343
  let body;
488
344
  body = JSON.stringify(se_ListComponentProvisionedResourcesInput(input, context));
489
345
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
490
346
  };
491
347
  exports.se_ListComponentProvisionedResourcesCommand = se_ListComponentProvisionedResourcesCommand;
492
348
  const se_ListComponentsCommand = async (input, context) => {
493
- const headers = {
494
- "content-type": "application/x-amz-json-1.0",
495
- "x-amz-target": "AwsProton20200720.ListComponents",
496
- };
349
+ const headers = sharedHeaders("ListComponents");
497
350
  let body;
498
351
  body = JSON.stringify(se_ListComponentsInput(input, context));
499
352
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
500
353
  };
501
354
  exports.se_ListComponentsCommand = se_ListComponentsCommand;
502
355
  const se_ListEnvironmentAccountConnectionsCommand = async (input, context) => {
503
- const headers = {
504
- "content-type": "application/x-amz-json-1.0",
505
- "x-amz-target": "AwsProton20200720.ListEnvironmentAccountConnections",
506
- };
356
+ const headers = sharedHeaders("ListEnvironmentAccountConnections");
507
357
  let body;
508
358
  body = JSON.stringify(se_ListEnvironmentAccountConnectionsInput(input, context));
509
359
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
510
360
  };
511
361
  exports.se_ListEnvironmentAccountConnectionsCommand = se_ListEnvironmentAccountConnectionsCommand;
512
362
  const se_ListEnvironmentOutputsCommand = async (input, context) => {
513
- const headers = {
514
- "content-type": "application/x-amz-json-1.0",
515
- "x-amz-target": "AwsProton20200720.ListEnvironmentOutputs",
516
- };
363
+ const headers = sharedHeaders("ListEnvironmentOutputs");
517
364
  let body;
518
365
  body = JSON.stringify(se_ListEnvironmentOutputsInput(input, context));
519
366
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
520
367
  };
521
368
  exports.se_ListEnvironmentOutputsCommand = se_ListEnvironmentOutputsCommand;
522
369
  const se_ListEnvironmentProvisionedResourcesCommand = async (input, context) => {
523
- const headers = {
524
- "content-type": "application/x-amz-json-1.0",
525
- "x-amz-target": "AwsProton20200720.ListEnvironmentProvisionedResources",
526
- };
370
+ const headers = sharedHeaders("ListEnvironmentProvisionedResources");
527
371
  let body;
528
372
  body = JSON.stringify(se_ListEnvironmentProvisionedResourcesInput(input, context));
529
373
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
530
374
  };
531
375
  exports.se_ListEnvironmentProvisionedResourcesCommand = se_ListEnvironmentProvisionedResourcesCommand;
532
376
  const se_ListEnvironmentsCommand = async (input, context) => {
533
- const headers = {
534
- "content-type": "application/x-amz-json-1.0",
535
- "x-amz-target": "AwsProton20200720.ListEnvironments",
536
- };
377
+ const headers = sharedHeaders("ListEnvironments");
537
378
  let body;
538
379
  body = JSON.stringify(se_ListEnvironmentsInput(input, context));
539
380
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
540
381
  };
541
382
  exports.se_ListEnvironmentsCommand = se_ListEnvironmentsCommand;
542
383
  const se_ListEnvironmentTemplatesCommand = async (input, context) => {
543
- const headers = {
544
- "content-type": "application/x-amz-json-1.0",
545
- "x-amz-target": "AwsProton20200720.ListEnvironmentTemplates",
546
- };
384
+ const headers = sharedHeaders("ListEnvironmentTemplates");
547
385
  let body;
548
386
  body = JSON.stringify(se_ListEnvironmentTemplatesInput(input, context));
549
387
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
550
388
  };
551
389
  exports.se_ListEnvironmentTemplatesCommand = se_ListEnvironmentTemplatesCommand;
552
390
  const se_ListEnvironmentTemplateVersionsCommand = async (input, context) => {
553
- const headers = {
554
- "content-type": "application/x-amz-json-1.0",
555
- "x-amz-target": "AwsProton20200720.ListEnvironmentTemplateVersions",
556
- };
391
+ const headers = sharedHeaders("ListEnvironmentTemplateVersions");
557
392
  let body;
558
393
  body = JSON.stringify(se_ListEnvironmentTemplateVersionsInput(input, context));
559
394
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
560
395
  };
561
396
  exports.se_ListEnvironmentTemplateVersionsCommand = se_ListEnvironmentTemplateVersionsCommand;
562
397
  const se_ListRepositoriesCommand = async (input, context) => {
563
- const headers = {
564
- "content-type": "application/x-amz-json-1.0",
565
- "x-amz-target": "AwsProton20200720.ListRepositories",
566
- };
398
+ const headers = sharedHeaders("ListRepositories");
567
399
  let body;
568
400
  body = JSON.stringify(se_ListRepositoriesInput(input, context));
569
401
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
570
402
  };
571
403
  exports.se_ListRepositoriesCommand = se_ListRepositoriesCommand;
572
404
  const se_ListRepositorySyncDefinitionsCommand = async (input, context) => {
573
- const headers = {
574
- "content-type": "application/x-amz-json-1.0",
575
- "x-amz-target": "AwsProton20200720.ListRepositorySyncDefinitions",
576
- };
405
+ const headers = sharedHeaders("ListRepositorySyncDefinitions");
577
406
  let body;
578
407
  body = JSON.stringify(se_ListRepositorySyncDefinitionsInput(input, context));
579
408
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
580
409
  };
581
410
  exports.se_ListRepositorySyncDefinitionsCommand = se_ListRepositorySyncDefinitionsCommand;
582
411
  const se_ListServiceInstanceOutputsCommand = async (input, context) => {
583
- const headers = {
584
- "content-type": "application/x-amz-json-1.0",
585
- "x-amz-target": "AwsProton20200720.ListServiceInstanceOutputs",
586
- };
412
+ const headers = sharedHeaders("ListServiceInstanceOutputs");
587
413
  let body;
588
414
  body = JSON.stringify(se_ListServiceInstanceOutputsInput(input, context));
589
415
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
590
416
  };
591
417
  exports.se_ListServiceInstanceOutputsCommand = se_ListServiceInstanceOutputsCommand;
592
418
  const se_ListServiceInstanceProvisionedResourcesCommand = async (input, context) => {
593
- const headers = {
594
- "content-type": "application/x-amz-json-1.0",
595
- "x-amz-target": "AwsProton20200720.ListServiceInstanceProvisionedResources",
596
- };
419
+ const headers = sharedHeaders("ListServiceInstanceProvisionedResources");
597
420
  let body;
598
421
  body = JSON.stringify(se_ListServiceInstanceProvisionedResourcesInput(input, context));
599
422
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
600
423
  };
601
424
  exports.se_ListServiceInstanceProvisionedResourcesCommand = se_ListServiceInstanceProvisionedResourcesCommand;
602
425
  const se_ListServiceInstancesCommand = async (input, context) => {
603
- const headers = {
604
- "content-type": "application/x-amz-json-1.0",
605
- "x-amz-target": "AwsProton20200720.ListServiceInstances",
606
- };
426
+ const headers = sharedHeaders("ListServiceInstances");
607
427
  let body;
608
428
  body = JSON.stringify(se_ListServiceInstancesInput(input, context));
609
429
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
610
430
  };
611
431
  exports.se_ListServiceInstancesCommand = se_ListServiceInstancesCommand;
612
432
  const se_ListServicePipelineOutputsCommand = async (input, context) => {
613
- const headers = {
614
- "content-type": "application/x-amz-json-1.0",
615
- "x-amz-target": "AwsProton20200720.ListServicePipelineOutputs",
616
- };
433
+ const headers = sharedHeaders("ListServicePipelineOutputs");
617
434
  let body;
618
435
  body = JSON.stringify(se_ListServicePipelineOutputsInput(input, context));
619
436
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
620
437
  };
621
438
  exports.se_ListServicePipelineOutputsCommand = se_ListServicePipelineOutputsCommand;
622
439
  const se_ListServicePipelineProvisionedResourcesCommand = async (input, context) => {
623
- const headers = {
624
- "content-type": "application/x-amz-json-1.0",
625
- "x-amz-target": "AwsProton20200720.ListServicePipelineProvisionedResources",
626
- };
440
+ const headers = sharedHeaders("ListServicePipelineProvisionedResources");
627
441
  let body;
628
442
  body = JSON.stringify(se_ListServicePipelineProvisionedResourcesInput(input, context));
629
443
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
630
444
  };
631
445
  exports.se_ListServicePipelineProvisionedResourcesCommand = se_ListServicePipelineProvisionedResourcesCommand;
632
446
  const se_ListServicesCommand = async (input, context) => {
633
- const headers = {
634
- "content-type": "application/x-amz-json-1.0",
635
- "x-amz-target": "AwsProton20200720.ListServices",
636
- };
447
+ const headers = sharedHeaders("ListServices");
637
448
  let body;
638
449
  body = JSON.stringify(se_ListServicesInput(input, context));
639
450
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
640
451
  };
641
452
  exports.se_ListServicesCommand = se_ListServicesCommand;
642
453
  const se_ListServiceTemplatesCommand = async (input, context) => {
643
- const headers = {
644
- "content-type": "application/x-amz-json-1.0",
645
- "x-amz-target": "AwsProton20200720.ListServiceTemplates",
646
- };
454
+ const headers = sharedHeaders("ListServiceTemplates");
647
455
  let body;
648
456
  body = JSON.stringify(se_ListServiceTemplatesInput(input, context));
649
457
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
650
458
  };
651
459
  exports.se_ListServiceTemplatesCommand = se_ListServiceTemplatesCommand;
652
460
  const se_ListServiceTemplateVersionsCommand = async (input, context) => {
653
- const headers = {
654
- "content-type": "application/x-amz-json-1.0",
655
- "x-amz-target": "AwsProton20200720.ListServiceTemplateVersions",
656
- };
461
+ const headers = sharedHeaders("ListServiceTemplateVersions");
657
462
  let body;
658
463
  body = JSON.stringify(se_ListServiceTemplateVersionsInput(input, context));
659
464
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
660
465
  };
661
466
  exports.se_ListServiceTemplateVersionsCommand = se_ListServiceTemplateVersionsCommand;
662
467
  const se_ListTagsForResourceCommand = async (input, context) => {
663
- const headers = {
664
- "content-type": "application/x-amz-json-1.0",
665
- "x-amz-target": "AwsProton20200720.ListTagsForResource",
666
- };
468
+ const headers = sharedHeaders("ListTagsForResource");
667
469
  let body;
668
470
  body = JSON.stringify(se_ListTagsForResourceInput(input, context));
669
471
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
670
472
  };
671
473
  exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
672
474
  const se_NotifyResourceDeploymentStatusChangeCommand = async (input, context) => {
673
- const headers = {
674
- "content-type": "application/x-amz-json-1.0",
675
- "x-amz-target": "AwsProton20200720.NotifyResourceDeploymentStatusChange",
676
- };
475
+ const headers = sharedHeaders("NotifyResourceDeploymentStatusChange");
677
476
  let body;
678
477
  body = JSON.stringify(se_NotifyResourceDeploymentStatusChangeInput(input, context));
679
478
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
680
479
  };
681
480
  exports.se_NotifyResourceDeploymentStatusChangeCommand = se_NotifyResourceDeploymentStatusChangeCommand;
682
481
  const se_RejectEnvironmentAccountConnectionCommand = async (input, context) => {
683
- const headers = {
684
- "content-type": "application/x-amz-json-1.0",
685
- "x-amz-target": "AwsProton20200720.RejectEnvironmentAccountConnection",
686
- };
482
+ const headers = sharedHeaders("RejectEnvironmentAccountConnection");
687
483
  let body;
688
484
  body = JSON.stringify(se_RejectEnvironmentAccountConnectionInput(input, context));
689
485
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
690
486
  };
691
487
  exports.se_RejectEnvironmentAccountConnectionCommand = se_RejectEnvironmentAccountConnectionCommand;
692
488
  const se_TagResourceCommand = async (input, context) => {
693
- const headers = {
694
- "content-type": "application/x-amz-json-1.0",
695
- "x-amz-target": "AwsProton20200720.TagResource",
696
- };
489
+ const headers = sharedHeaders("TagResource");
697
490
  let body;
698
491
  body = JSON.stringify(se_TagResourceInput(input, context));
699
492
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
700
493
  };
701
494
  exports.se_TagResourceCommand = se_TagResourceCommand;
702
495
  const se_UntagResourceCommand = async (input, context) => {
703
- const headers = {
704
- "content-type": "application/x-amz-json-1.0",
705
- "x-amz-target": "AwsProton20200720.UntagResource",
706
- };
496
+ const headers = sharedHeaders("UntagResource");
707
497
  let body;
708
498
  body = JSON.stringify(se_UntagResourceInput(input, context));
709
499
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
710
500
  };
711
501
  exports.se_UntagResourceCommand = se_UntagResourceCommand;
712
502
  const se_UpdateAccountSettingsCommand = async (input, context) => {
713
- const headers = {
714
- "content-type": "application/x-amz-json-1.0",
715
- "x-amz-target": "AwsProton20200720.UpdateAccountSettings",
716
- };
503
+ const headers = sharedHeaders("UpdateAccountSettings");
717
504
  let body;
718
505
  body = JSON.stringify(se_UpdateAccountSettingsInput(input, context));
719
506
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
720
507
  };
721
508
  exports.se_UpdateAccountSettingsCommand = se_UpdateAccountSettingsCommand;
722
509
  const se_UpdateComponentCommand = async (input, context) => {
723
- const headers = {
724
- "content-type": "application/x-amz-json-1.0",
725
- "x-amz-target": "AwsProton20200720.UpdateComponent",
726
- };
510
+ const headers = sharedHeaders("UpdateComponent");
727
511
  let body;
728
512
  body = JSON.stringify(se_UpdateComponentInput(input, context));
729
513
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
730
514
  };
731
515
  exports.se_UpdateComponentCommand = se_UpdateComponentCommand;
732
516
  const se_UpdateEnvironmentCommand = async (input, context) => {
733
- const headers = {
734
- "content-type": "application/x-amz-json-1.0",
735
- "x-amz-target": "AwsProton20200720.UpdateEnvironment",
736
- };
517
+ const headers = sharedHeaders("UpdateEnvironment");
737
518
  let body;
738
519
  body = JSON.stringify(se_UpdateEnvironmentInput(input, context));
739
520
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
740
521
  };
741
522
  exports.se_UpdateEnvironmentCommand = se_UpdateEnvironmentCommand;
742
523
  const se_UpdateEnvironmentAccountConnectionCommand = async (input, context) => {
743
- const headers = {
744
- "content-type": "application/x-amz-json-1.0",
745
- "x-amz-target": "AwsProton20200720.UpdateEnvironmentAccountConnection",
746
- };
524
+ const headers = sharedHeaders("UpdateEnvironmentAccountConnection");
747
525
  let body;
748
526
  body = JSON.stringify(se_UpdateEnvironmentAccountConnectionInput(input, context));
749
527
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
750
528
  };
751
529
  exports.se_UpdateEnvironmentAccountConnectionCommand = se_UpdateEnvironmentAccountConnectionCommand;
752
530
  const se_UpdateEnvironmentTemplateCommand = async (input, context) => {
753
- const headers = {
754
- "content-type": "application/x-amz-json-1.0",
755
- "x-amz-target": "AwsProton20200720.UpdateEnvironmentTemplate",
756
- };
531
+ const headers = sharedHeaders("UpdateEnvironmentTemplate");
757
532
  let body;
758
533
  body = JSON.stringify(se_UpdateEnvironmentTemplateInput(input, context));
759
534
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
760
535
  };
761
536
  exports.se_UpdateEnvironmentTemplateCommand = se_UpdateEnvironmentTemplateCommand;
762
537
  const se_UpdateEnvironmentTemplateVersionCommand = async (input, context) => {
763
- const headers = {
764
- "content-type": "application/x-amz-json-1.0",
765
- "x-amz-target": "AwsProton20200720.UpdateEnvironmentTemplateVersion",
766
- };
538
+ const headers = sharedHeaders("UpdateEnvironmentTemplateVersion");
767
539
  let body;
768
540
  body = JSON.stringify(se_UpdateEnvironmentTemplateVersionInput(input, context));
769
541
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
770
542
  };
771
543
  exports.se_UpdateEnvironmentTemplateVersionCommand = se_UpdateEnvironmentTemplateVersionCommand;
772
544
  const se_UpdateServiceCommand = async (input, context) => {
773
- const headers = {
774
- "content-type": "application/x-amz-json-1.0",
775
- "x-amz-target": "AwsProton20200720.UpdateService",
776
- };
545
+ const headers = sharedHeaders("UpdateService");
777
546
  let body;
778
547
  body = JSON.stringify(se_UpdateServiceInput(input, context));
779
548
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
780
549
  };
781
550
  exports.se_UpdateServiceCommand = se_UpdateServiceCommand;
782
551
  const se_UpdateServiceInstanceCommand = async (input, context) => {
783
- const headers = {
784
- "content-type": "application/x-amz-json-1.0",
785
- "x-amz-target": "AwsProton20200720.UpdateServiceInstance",
786
- };
552
+ const headers = sharedHeaders("UpdateServiceInstance");
787
553
  let body;
788
554
  body = JSON.stringify(se_UpdateServiceInstanceInput(input, context));
789
555
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
790
556
  };
791
557
  exports.se_UpdateServiceInstanceCommand = se_UpdateServiceInstanceCommand;
792
558
  const se_UpdateServicePipelineCommand = async (input, context) => {
793
- const headers = {
794
- "content-type": "application/x-amz-json-1.0",
795
- "x-amz-target": "AwsProton20200720.UpdateServicePipeline",
796
- };
559
+ const headers = sharedHeaders("UpdateServicePipeline");
797
560
  let body;
798
561
  body = JSON.stringify(se_UpdateServicePipelineInput(input, context));
799
562
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
800
563
  };
801
564
  exports.se_UpdateServicePipelineCommand = se_UpdateServicePipelineCommand;
802
565
  const se_UpdateServiceSyncBlockerCommand = async (input, context) => {
803
- const headers = {
804
- "content-type": "application/x-amz-json-1.0",
805
- "x-amz-target": "AwsProton20200720.UpdateServiceSyncBlocker",
806
- };
566
+ const headers = sharedHeaders("UpdateServiceSyncBlocker");
807
567
  let body;
808
568
  body = JSON.stringify(se_UpdateServiceSyncBlockerInput(input, context));
809
569
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
810
570
  };
811
571
  exports.se_UpdateServiceSyncBlockerCommand = se_UpdateServiceSyncBlockerCommand;
812
572
  const se_UpdateServiceSyncConfigCommand = async (input, context) => {
813
- const headers = {
814
- "content-type": "application/x-amz-json-1.0",
815
- "x-amz-target": "AwsProton20200720.UpdateServiceSyncConfig",
816
- };
573
+ const headers = sharedHeaders("UpdateServiceSyncConfig");
817
574
  let body;
818
575
  body = JSON.stringify(se_UpdateServiceSyncConfigInput(input, context));
819
576
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
820
577
  };
821
578
  exports.se_UpdateServiceSyncConfigCommand = se_UpdateServiceSyncConfigCommand;
822
579
  const se_UpdateServiceTemplateCommand = async (input, context) => {
823
- const headers = {
824
- "content-type": "application/x-amz-json-1.0",
825
- "x-amz-target": "AwsProton20200720.UpdateServiceTemplate",
826
- };
580
+ const headers = sharedHeaders("UpdateServiceTemplate");
827
581
  let body;
828
582
  body = JSON.stringify(se_UpdateServiceTemplateInput(input, context));
829
583
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
830
584
  };
831
585
  exports.se_UpdateServiceTemplateCommand = se_UpdateServiceTemplateCommand;
832
586
  const se_UpdateServiceTemplateVersionCommand = async (input, context) => {
833
- const headers = {
834
- "content-type": "application/x-amz-json-1.0",
835
- "x-amz-target": "AwsProton20200720.UpdateServiceTemplateVersion",
836
- };
587
+ const headers = sharedHeaders("UpdateServiceTemplateVersion");
837
588
  let body;
838
589
  body = JSON.stringify(se_UpdateServiceTemplateVersionInput(input, context));
839
590
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
840
591
  };
841
592
  exports.se_UpdateServiceTemplateVersionCommand = se_UpdateServiceTemplateVersionCommand;
842
593
  const se_UpdateTemplateSyncConfigCommand = async (input, context) => {
843
- const headers = {
844
- "content-type": "application/x-amz-json-1.0",
845
- "x-amz-target": "AwsProton20200720.UpdateTemplateSyncConfig",
846
- };
594
+ const headers = sharedHeaders("UpdateTemplateSyncConfig");
847
595
  let body;
848
596
  body = JSON.stringify(se_UpdateTemplateSyncConfigInput(input, context));
849
597
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
@@ -6958,6 +6706,12 @@ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, bod
6958
6706
  }
6959
6707
  return new protocol_http_1.HttpRequest(contents);
6960
6708
  };
6709
+ function sharedHeaders(operation) {
6710
+ return {
6711
+ "content-type": "application/x-amz-json-1.0",
6712
+ "x-amz-target": `AwsProton20200720.${operation}`,
6713
+ };
6714
+ }
6961
6715
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
6962
6716
  if (encoded.length) {
6963
6717
  return JSON.parse(encoded);