@aws-sdk/client-controltower 3.901.0 → 3.906.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 (2) hide show
  1. package/dist-cjs/index.js +1894 -2079
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,2125 +1,1940 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- BaselineOperationStatus: () => BaselineOperationStatus,
26
- BaselineOperationType: () => BaselineOperationType,
27
- ConflictException: () => ConflictException,
28
- ControlOperationStatus: () => ControlOperationStatus,
29
- ControlOperationType: () => ControlOperationType,
30
- ControlTower: () => ControlTower,
31
- ControlTowerClient: () => ControlTowerClient,
32
- ControlTowerServiceException: () => ControlTowerServiceException,
33
- CreateLandingZoneCommand: () => CreateLandingZoneCommand,
34
- DeleteLandingZoneCommand: () => DeleteLandingZoneCommand,
35
- DisableBaselineCommand: () => DisableBaselineCommand,
36
- DisableControlCommand: () => DisableControlCommand,
37
- DriftStatus: () => DriftStatus,
38
- EnableBaselineCommand: () => EnableBaselineCommand,
39
- EnableControlCommand: () => EnableControlCommand,
40
- EnabledBaselineDriftStatus: () => EnabledBaselineDriftStatus,
41
- EnablementStatus: () => EnablementStatus,
42
- GetBaselineCommand: () => GetBaselineCommand,
43
- GetBaselineOperationCommand: () => GetBaselineOperationCommand,
44
- GetControlOperationCommand: () => GetControlOperationCommand,
45
- GetEnabledBaselineCommand: () => GetEnabledBaselineCommand,
46
- GetEnabledControlCommand: () => GetEnabledControlCommand,
47
- GetLandingZoneCommand: () => GetLandingZoneCommand,
48
- GetLandingZoneOperationCommand: () => GetLandingZoneOperationCommand,
49
- InternalServerException: () => InternalServerException,
50
- LandingZoneDriftStatus: () => LandingZoneDriftStatus,
51
- LandingZoneOperationStatus: () => LandingZoneOperationStatus,
52
- LandingZoneOperationType: () => LandingZoneOperationType,
53
- LandingZoneStatus: () => LandingZoneStatus,
54
- ListBaselinesCommand: () => ListBaselinesCommand,
55
- ListControlOperationsCommand: () => ListControlOperationsCommand,
56
- ListEnabledBaselinesCommand: () => ListEnabledBaselinesCommand,
57
- ListEnabledControlsCommand: () => ListEnabledControlsCommand,
58
- ListLandingZoneOperationsCommand: () => ListLandingZoneOperationsCommand,
59
- ListLandingZonesCommand: () => ListLandingZonesCommand,
60
- ListTagsForResourceCommand: () => ListTagsForResourceCommand,
61
- ResetEnabledBaselineCommand: () => ResetEnabledBaselineCommand,
62
- ResetEnabledControlCommand: () => ResetEnabledControlCommand,
63
- ResetLandingZoneCommand: () => ResetLandingZoneCommand,
64
- ResourceNotFoundException: () => ResourceNotFoundException,
65
- ServiceQuotaExceededException: () => ServiceQuotaExceededException,
66
- TagResourceCommand: () => TagResourceCommand,
67
- ThrottlingException: () => ThrottlingException,
68
- UntagResourceCommand: () => UntagResourceCommand,
69
- UpdateEnabledBaselineCommand: () => UpdateEnabledBaselineCommand,
70
- UpdateEnabledControlCommand: () => UpdateEnabledControlCommand,
71
- UpdateLandingZoneCommand: () => UpdateLandingZoneCommand,
72
- ValidationException: () => ValidationException,
73
- __Client: () => import_smithy_client.Client,
74
- paginateListBaselines: () => paginateListBaselines,
75
- paginateListControlOperations: () => paginateListControlOperations,
76
- paginateListEnabledBaselines: () => paginateListEnabledBaselines,
77
- paginateListEnabledControls: () => paginateListEnabledControls,
78
- paginateListLandingZoneOperations: () => paginateListLandingZoneOperations,
79
- paginateListLandingZones: () => paginateListLandingZones
80
- });
81
- module.exports = __toCommonJS(index_exports);
82
-
83
- // src/ControlTowerClient.ts
84
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
85
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
86
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
87
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
88
- var import_config_resolver = require("@smithy/config-resolver");
89
- var import_core = require("@smithy/core");
90
- var import_middleware_content_length = require("@smithy/middleware-content-length");
91
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
92
- var import_middleware_retry = require("@smithy/middleware-retry");
93
-
94
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
95
-
96
- // src/endpoint/EndpointParameters.ts
97
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
98
- return Object.assign(options, {
99
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
100
- useFipsEndpoint: options.useFipsEndpoint ?? false,
101
- defaultSigningName: "controltower"
102
- });
103
- }, "resolveClientEndpointParameters");
104
- var commonParams = {
105
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
106
- Endpoint: { type: "builtInParams", name: "endpoint" },
107
- Region: { type: "builtInParams", name: "region" },
108
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "controltower",
25
+ });
26
+ };
27
+ const commonParams = {
28
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
29
+ Endpoint: { type: "builtInParams", name: "endpoint" },
30
+ Region: { type: "builtInParams", name: "region" },
31
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
109
32
  };
110
33
 
111
- // src/ControlTowerClient.ts
112
- var import_runtimeConfig = require("././runtimeConfig");
34
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
35
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
36
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
37
+ let _credentials = runtimeConfig.credentials;
38
+ return {
39
+ setHttpAuthScheme(httpAuthScheme) {
40
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
41
+ if (index === -1) {
42
+ _httpAuthSchemes.push(httpAuthScheme);
43
+ }
44
+ else {
45
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
46
+ }
47
+ },
48
+ httpAuthSchemes() {
49
+ return _httpAuthSchemes;
50
+ },
51
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
52
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
53
+ },
54
+ httpAuthSchemeProvider() {
55
+ return _httpAuthSchemeProvider;
56
+ },
57
+ setCredentials(credentials) {
58
+ _credentials = credentials;
59
+ },
60
+ credentials() {
61
+ return _credentials;
62
+ },
63
+ };
64
+ };
65
+ const resolveHttpAuthRuntimeConfig = (config) => {
66
+ return {
67
+ httpAuthSchemes: config.httpAuthSchemes(),
68
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
69
+ credentials: config.credentials(),
70
+ };
71
+ };
113
72
 
114
- // src/runtimeExtensions.ts
115
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
116
- var import_protocol_http = require("@smithy/protocol-http");
117
- var import_smithy_client = require("@smithy/smithy-client");
73
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
74
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
75
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
76
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
77
+ };
118
78
 
119
- // src/auth/httpAuthExtensionConfiguration.ts
120
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
121
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
122
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
123
- let _credentials = runtimeConfig.credentials;
124
- return {
125
- setHttpAuthScheme(httpAuthScheme) {
126
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
127
- if (index === -1) {
128
- _httpAuthSchemes.push(httpAuthScheme);
129
- } else {
130
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
131
- }
132
- },
133
- httpAuthSchemes() {
134
- return _httpAuthSchemes;
135
- },
136
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
137
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
138
- },
139
- httpAuthSchemeProvider() {
140
- return _httpAuthSchemeProvider;
141
- },
142
- setCredentials(credentials) {
143
- _credentials = credentials;
144
- },
145
- credentials() {
146
- return _credentials;
79
+ class ControlTowerClient extends smithyClient.Client {
80
+ config;
81
+ constructor(...[configuration]) {
82
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
83
+ super(_config_0);
84
+ this.initConfig = _config_0;
85
+ const _config_1 = resolveClientEndpointParameters(_config_0);
86
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
87
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
88
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
89
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
90
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
91
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
92
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
93
+ this.config = _config_8;
94
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
95
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
96
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
97
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
98
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
99
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
100
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
101
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultControlTowerHttpAuthSchemeParametersProvider,
102
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
103
+ "aws.auth#sigv4": config.credentials,
104
+ }),
105
+ }));
106
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
147
107
  }
148
- };
149
- }, "getHttpAuthExtensionConfiguration");
150
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
151
- return {
152
- httpAuthSchemes: config.httpAuthSchemes(),
153
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
154
- credentials: config.credentials()
155
- };
156
- }, "resolveHttpAuthRuntimeConfig");
157
-
158
- // src/runtimeExtensions.ts
159
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
160
- const extensionConfiguration = Object.assign(
161
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
162
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
163
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
164
- getHttpAuthExtensionConfiguration(runtimeConfig)
165
- );
166
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
167
- return Object.assign(
168
- runtimeConfig,
169
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
170
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
171
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
172
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
173
- );
174
- }, "resolveRuntimeExtensions");
108
+ destroy() {
109
+ super.destroy();
110
+ }
111
+ }
175
112
 
176
- // src/ControlTowerClient.ts
177
- var ControlTowerClient = class extends import_smithy_client.Client {
178
- static {
179
- __name(this, "ControlTowerClient");
180
- }
181
- /**
182
- * The resolved configuration of ControlTowerClient class. This is resolved and normalized from the {@link ControlTowerClientConfig | constructor configuration interface}.
183
- */
184
- config;
185
- constructor(...[configuration]) {
186
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
187
- super(_config_0);
188
- this.initConfig = _config_0;
189
- const _config_1 = resolveClientEndpointParameters(_config_0);
190
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
191
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
192
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
193
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
194
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
195
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
196
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
197
- this.config = _config_8;
198
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
199
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
200
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
201
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
202
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
203
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
204
- this.middlewareStack.use(
205
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
206
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultControlTowerHttpAuthSchemeParametersProvider,
207
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
208
- "aws.auth#sigv4": config.credentials
209
- }), "identityProviderConfigProvider")
210
- })
211
- );
212
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
213
- }
214
- /**
215
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
216
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
217
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
218
- */
219
- destroy() {
220
- super.destroy();
221
- }
113
+ class ControlTowerServiceException extends smithyClient.ServiceException {
114
+ constructor(options) {
115
+ super(options);
116
+ Object.setPrototypeOf(this, ControlTowerServiceException.prototype);
117
+ }
118
+ }
119
+
120
+ class AccessDeniedException extends ControlTowerServiceException {
121
+ name = "AccessDeniedException";
122
+ $fault = "client";
123
+ constructor(opts) {
124
+ super({
125
+ name: "AccessDeniedException",
126
+ $fault: "client",
127
+ ...opts,
128
+ });
129
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
130
+ }
131
+ }
132
+ const BaselineOperationType = {
133
+ DISABLE_BASELINE: "DISABLE_BASELINE",
134
+ ENABLE_BASELINE: "ENABLE_BASELINE",
135
+ RESET_ENABLED_BASELINE: "RESET_ENABLED_BASELINE",
136
+ UPDATE_ENABLED_BASELINE: "UPDATE_ENABLED_BASELINE",
222
137
  };
223
-
224
- // src/ControlTower.ts
225
-
226
-
227
- // src/commands/CreateLandingZoneCommand.ts
228
-
229
- var import_middleware_serde = require("@smithy/middleware-serde");
230
-
231
-
232
- // src/protocols/Aws_restJson1.ts
233
- var import_core2 = require("@aws-sdk/core");
234
-
235
-
236
-
237
- // src/models/ControlTowerServiceException.ts
238
-
239
- var ControlTowerServiceException = class _ControlTowerServiceException extends import_smithy_client.ServiceException {
240
- static {
241
- __name(this, "ControlTowerServiceException");
242
- }
243
- /**
244
- * @internal
245
- */
246
- constructor(options) {
247
- super(options);
248
- Object.setPrototypeOf(this, _ControlTowerServiceException.prototype);
249
- }
138
+ const BaselineOperationStatus = {
139
+ FAILED: "FAILED",
140
+ IN_PROGRESS: "IN_PROGRESS",
141
+ SUCCEEDED: "SUCCEEDED",
250
142
  };
251
-
252
- // src/models/models_0.ts
253
- var AccessDeniedException = class _AccessDeniedException extends ControlTowerServiceException {
254
- static {
255
- __name(this, "AccessDeniedException");
256
- }
257
- name = "AccessDeniedException";
258
- $fault = "client";
259
- /**
260
- * @internal
261
- */
262
- constructor(opts) {
263
- super({
264
- name: "AccessDeniedException",
265
- $fault: "client",
266
- ...opts
267
- });
268
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
269
- }
270
- };
271
- var BaselineOperationType = {
272
- DISABLE_BASELINE: "DISABLE_BASELINE",
273
- ENABLE_BASELINE: "ENABLE_BASELINE",
274
- RESET_ENABLED_BASELINE: "RESET_ENABLED_BASELINE",
275
- UPDATE_ENABLED_BASELINE: "UPDATE_ENABLED_BASELINE"
276
- };
277
- var BaselineOperationStatus = {
278
- FAILED: "FAILED",
279
- IN_PROGRESS: "IN_PROGRESS",
280
- SUCCEEDED: "SUCCEEDED"
281
- };
282
- var InternalServerException = class _InternalServerException extends ControlTowerServiceException {
283
- static {
284
- __name(this, "InternalServerException");
285
- }
286
- name = "InternalServerException";
287
- $fault = "server";
288
- $retryable = {};
289
- /**
290
- * @internal
291
- */
292
- constructor(opts) {
293
- super({
294
- name: "InternalServerException",
295
- $fault: "server",
296
- ...opts
297
- });
298
- Object.setPrototypeOf(this, _InternalServerException.prototype);
299
- }
300
- };
301
- var ResourceNotFoundException = class _ResourceNotFoundException extends ControlTowerServiceException {
302
- static {
303
- __name(this, "ResourceNotFoundException");
304
- }
305
- name = "ResourceNotFoundException";
306
- $fault = "client";
307
- /**
308
- * @internal
309
- */
310
- constructor(opts) {
311
- super({
312
- name: "ResourceNotFoundException",
313
- $fault: "client",
314
- ...opts
315
- });
316
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
317
- }
318
- };
319
- var ThrottlingException = class _ThrottlingException extends ControlTowerServiceException {
320
- static {
321
- __name(this, "ThrottlingException");
322
- }
323
- name = "ThrottlingException";
324
- $fault = "client";
325
- $retryable = {
326
- throttling: true
327
- };
328
- /**
329
- * <p>The ID of the service that is associated with the error.</p>
330
- * @public
331
- */
332
- serviceCode;
333
- /**
334
- * <p>The ID of the service quota that was exceeded.</p>
335
- * @public
336
- */
337
- quotaCode;
338
- /**
339
- * <p>The number of seconds the caller should wait before retrying.</p>
340
- * @public
341
- */
342
- retryAfterSeconds;
343
- /**
344
- * @internal
345
- */
346
- constructor(opts) {
347
- super({
348
- name: "ThrottlingException",
349
- $fault: "client",
350
- ...opts
351
- });
352
- Object.setPrototypeOf(this, _ThrottlingException.prototype);
353
- this.serviceCode = opts.serviceCode;
354
- this.quotaCode = opts.quotaCode;
355
- this.retryAfterSeconds = opts.retryAfterSeconds;
356
- }
357
- };
358
- var ValidationException = class _ValidationException extends ControlTowerServiceException {
359
- static {
360
- __name(this, "ValidationException");
361
- }
362
- name = "ValidationException";
363
- $fault = "client";
364
- /**
365
- * @internal
366
- */
367
- constructor(opts) {
368
- super({
369
- name: "ValidationException",
370
- $fault: "client",
371
- ...opts
372
- });
373
- Object.setPrototypeOf(this, _ValidationException.prototype);
374
- }
375
- };
376
- var ControlOperationType = {
377
- DISABLE_CONTROL: "DISABLE_CONTROL",
378
- ENABLE_CONTROL: "ENABLE_CONTROL",
379
- RESET_ENABLED_CONTROL: "RESET_ENABLED_CONTROL",
380
- UPDATE_ENABLED_CONTROL: "UPDATE_ENABLED_CONTROL"
381
- };
382
- var ControlOperationStatus = {
383
- FAILED: "FAILED",
384
- IN_PROGRESS: "IN_PROGRESS",
385
- SUCCEEDED: "SUCCEEDED"
386
- };
387
- var ConflictException = class _ConflictException extends ControlTowerServiceException {
388
- static {
389
- __name(this, "ConflictException");
390
- }
391
- name = "ConflictException";
392
- $fault = "client";
393
- /**
394
- * @internal
395
- */
396
- constructor(opts) {
397
- super({
398
- name: "ConflictException",
399
- $fault: "client",
400
- ...opts
401
- });
402
- Object.setPrototypeOf(this, _ConflictException.prototype);
403
- }
404
- };
405
- var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends ControlTowerServiceException {
406
- static {
407
- __name(this, "ServiceQuotaExceededException");
408
- }
409
- name = "ServiceQuotaExceededException";
410
- $fault = "client";
411
- /**
412
- * @internal
413
- */
414
- constructor(opts) {
415
- super({
416
- name: "ServiceQuotaExceededException",
417
- $fault: "client",
418
- ...opts
419
- });
420
- Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
421
- }
422
- };
423
- var EnabledBaselineDriftStatus = {
424
- DRIFTED: "DRIFTED",
425
- IN_SYNC: "IN_SYNC"
426
- };
427
- var EnablementStatus = {
428
- FAILED: "FAILED",
429
- SUCCEEDED: "SUCCEEDED",
430
- UNDER_CHANGE: "UNDER_CHANGE"
431
- };
432
- var DriftStatus = {
433
- DRIFTED: "DRIFTED",
434
- IN_SYNC: "IN_SYNC",
435
- NOT_CHECKING: "NOT_CHECKING",
436
- UNKNOWN: "UNKNOWN"
437
- };
438
- var LandingZoneOperationType = {
439
- CREATE: "CREATE",
440
- DELETE: "DELETE",
441
- RESET: "RESET",
442
- UPDATE: "UPDATE"
443
- };
444
- var LandingZoneOperationStatus = {
445
- FAILED: "FAILED",
446
- IN_PROGRESS: "IN_PROGRESS",
447
- SUCCEEDED: "SUCCEEDED"
448
- };
449
- var LandingZoneDriftStatus = {
450
- DRIFTED: "DRIFTED",
451
- IN_SYNC: "IN_SYNC"
452
- };
453
- var LandingZoneStatus = {
454
- ACTIVE: "ACTIVE",
455
- FAILED: "FAILED",
456
- PROCESSING: "PROCESSING"
143
+ class InternalServerException extends ControlTowerServiceException {
144
+ name = "InternalServerException";
145
+ $fault = "server";
146
+ $retryable = {};
147
+ constructor(opts) {
148
+ super({
149
+ name: "InternalServerException",
150
+ $fault: "server",
151
+ ...opts,
152
+ });
153
+ Object.setPrototypeOf(this, InternalServerException.prototype);
154
+ }
155
+ }
156
+ class ResourceNotFoundException extends ControlTowerServiceException {
157
+ name = "ResourceNotFoundException";
158
+ $fault = "client";
159
+ constructor(opts) {
160
+ super({
161
+ name: "ResourceNotFoundException",
162
+ $fault: "client",
163
+ ...opts,
164
+ });
165
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
166
+ }
167
+ }
168
+ class ThrottlingException extends ControlTowerServiceException {
169
+ name = "ThrottlingException";
170
+ $fault = "client";
171
+ $retryable = {
172
+ throttling: true,
173
+ };
174
+ serviceCode;
175
+ quotaCode;
176
+ retryAfterSeconds;
177
+ constructor(opts) {
178
+ super({
179
+ name: "ThrottlingException",
180
+ $fault: "client",
181
+ ...opts,
182
+ });
183
+ Object.setPrototypeOf(this, ThrottlingException.prototype);
184
+ this.serviceCode = opts.serviceCode;
185
+ this.quotaCode = opts.quotaCode;
186
+ this.retryAfterSeconds = opts.retryAfterSeconds;
187
+ }
188
+ }
189
+ class ValidationException extends ControlTowerServiceException {
190
+ name = "ValidationException";
191
+ $fault = "client";
192
+ constructor(opts) {
193
+ super({
194
+ name: "ValidationException",
195
+ $fault: "client",
196
+ ...opts,
197
+ });
198
+ Object.setPrototypeOf(this, ValidationException.prototype);
199
+ }
200
+ }
201
+ const ControlOperationType = {
202
+ DISABLE_CONTROL: "DISABLE_CONTROL",
203
+ ENABLE_CONTROL: "ENABLE_CONTROL",
204
+ RESET_ENABLED_CONTROL: "RESET_ENABLED_CONTROL",
205
+ UPDATE_ENABLED_CONTROL: "UPDATE_ENABLED_CONTROL",
457
206
  };
458
-
459
- // src/protocols/Aws_restJson1.ts
460
- var se_CreateLandingZoneCommand = /* @__PURE__ */ __name(async (input, context) => {
461
- const b = (0, import_core.requestBuilder)(input, context);
462
- const headers = {
463
- "content-type": "application/json"
464
- };
465
- b.bp("/create-landingzone");
466
- let body;
467
- body = JSON.stringify(
468
- (0, import_smithy_client.take)(input, {
469
- manifest: /* @__PURE__ */ __name((_) => se_Manifest(_, context), "manifest"),
470
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags"),
471
- version: []
472
- })
473
- );
474
- b.m("POST").h(headers).b(body);
475
- return b.build();
476
- }, "se_CreateLandingZoneCommand");
477
- var se_DeleteLandingZoneCommand = /* @__PURE__ */ __name(async (input, context) => {
478
- const b = (0, import_core.requestBuilder)(input, context);
479
- const headers = {
480
- "content-type": "application/json"
481
- };
482
- b.bp("/delete-landingzone");
483
- let body;
484
- body = JSON.stringify(
485
- (0, import_smithy_client.take)(input, {
486
- landingZoneIdentifier: []
487
- })
488
- );
489
- b.m("POST").h(headers).b(body);
490
- return b.build();
491
- }, "se_DeleteLandingZoneCommand");
492
- var se_DisableBaselineCommand = /* @__PURE__ */ __name(async (input, context) => {
493
- const b = (0, import_core.requestBuilder)(input, context);
494
- const headers = {
495
- "content-type": "application/json"
496
- };
497
- b.bp("/disable-baseline");
498
- let body;
499
- body = JSON.stringify(
500
- (0, import_smithy_client.take)(input, {
501
- enabledBaselineIdentifier: []
502
- })
503
- );
504
- b.m("POST").h(headers).b(body);
505
- return b.build();
506
- }, "se_DisableBaselineCommand");
507
- var se_DisableControlCommand = /* @__PURE__ */ __name(async (input, context) => {
508
- const b = (0, import_core.requestBuilder)(input, context);
509
- const headers = {
510
- "content-type": "application/json"
511
- };
512
- b.bp("/disable-control");
513
- let body;
514
- body = JSON.stringify(
515
- (0, import_smithy_client.take)(input, {
516
- controlIdentifier: [],
517
- targetIdentifier: []
518
- })
519
- );
520
- b.m("POST").h(headers).b(body);
521
- return b.build();
522
- }, "se_DisableControlCommand");
523
- var se_EnableBaselineCommand = /* @__PURE__ */ __name(async (input, context) => {
524
- const b = (0, import_core.requestBuilder)(input, context);
525
- const headers = {
526
- "content-type": "application/json"
527
- };
528
- b.bp("/enable-baseline");
529
- let body;
530
- body = JSON.stringify(
531
- (0, import_smithy_client.take)(input, {
532
- baselineIdentifier: [],
533
- baselineVersion: [],
534
- parameters: /* @__PURE__ */ __name((_) => se_EnabledBaselineParameters(_, context), "parameters"),
535
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags"),
536
- targetIdentifier: []
537
- })
538
- );
539
- b.m("POST").h(headers).b(body);
540
- return b.build();
541
- }, "se_EnableBaselineCommand");
542
- var se_EnableControlCommand = /* @__PURE__ */ __name(async (input, context) => {
543
- const b = (0, import_core.requestBuilder)(input, context);
544
- const headers = {
545
- "content-type": "application/json"
546
- };
547
- b.bp("/enable-control");
548
- let body;
549
- body = JSON.stringify(
550
- (0, import_smithy_client.take)(input, {
551
- controlIdentifier: [],
552
- parameters: /* @__PURE__ */ __name((_) => se_EnabledControlParameters(_, context), "parameters"),
553
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags"),
554
- targetIdentifier: []
555
- })
556
- );
557
- b.m("POST").h(headers).b(body);
558
- return b.build();
559
- }, "se_EnableControlCommand");
560
- var se_GetBaselineCommand = /* @__PURE__ */ __name(async (input, context) => {
561
- const b = (0, import_core.requestBuilder)(input, context);
562
- const headers = {
563
- "content-type": "application/json"
564
- };
565
- b.bp("/get-baseline");
566
- let body;
567
- body = JSON.stringify(
568
- (0, import_smithy_client.take)(input, {
569
- baselineIdentifier: []
570
- })
571
- );
572
- b.m("POST").h(headers).b(body);
573
- return b.build();
574
- }, "se_GetBaselineCommand");
575
- var se_GetBaselineOperationCommand = /* @__PURE__ */ __name(async (input, context) => {
576
- const b = (0, import_core.requestBuilder)(input, context);
577
- const headers = {
578
- "content-type": "application/json"
579
- };
580
- b.bp("/get-baseline-operation");
581
- let body;
582
- body = JSON.stringify(
583
- (0, import_smithy_client.take)(input, {
584
- operationIdentifier: []
585
- })
586
- );
587
- b.m("POST").h(headers).b(body);
588
- return b.build();
589
- }, "se_GetBaselineOperationCommand");
590
- var se_GetControlOperationCommand = /* @__PURE__ */ __name(async (input, context) => {
591
- const b = (0, import_core.requestBuilder)(input, context);
592
- const headers = {
593
- "content-type": "application/json"
594
- };
595
- b.bp("/get-control-operation");
596
- let body;
597
- body = JSON.stringify(
598
- (0, import_smithy_client.take)(input, {
599
- operationIdentifier: []
600
- })
601
- );
602
- b.m("POST").h(headers).b(body);
603
- return b.build();
604
- }, "se_GetControlOperationCommand");
605
- var se_GetEnabledBaselineCommand = /* @__PURE__ */ __name(async (input, context) => {
606
- const b = (0, import_core.requestBuilder)(input, context);
607
- const headers = {
608
- "content-type": "application/json"
609
- };
610
- b.bp("/get-enabled-baseline");
611
- let body;
612
- body = JSON.stringify(
613
- (0, import_smithy_client.take)(input, {
614
- enabledBaselineIdentifier: []
615
- })
616
- );
617
- b.m("POST").h(headers).b(body);
618
- return b.build();
619
- }, "se_GetEnabledBaselineCommand");
620
- var se_GetEnabledControlCommand = /* @__PURE__ */ __name(async (input, context) => {
621
- const b = (0, import_core.requestBuilder)(input, context);
622
- const headers = {
623
- "content-type": "application/json"
624
- };
625
- b.bp("/get-enabled-control");
626
- let body;
627
- body = JSON.stringify(
628
- (0, import_smithy_client.take)(input, {
629
- enabledControlIdentifier: []
630
- })
631
- );
632
- b.m("POST").h(headers).b(body);
633
- return b.build();
634
- }, "se_GetEnabledControlCommand");
635
- var se_GetLandingZoneCommand = /* @__PURE__ */ __name(async (input, context) => {
636
- const b = (0, import_core.requestBuilder)(input, context);
637
- const headers = {
638
- "content-type": "application/json"
639
- };
640
- b.bp("/get-landingzone");
641
- let body;
642
- body = JSON.stringify(
643
- (0, import_smithy_client.take)(input, {
644
- landingZoneIdentifier: []
645
- })
646
- );
647
- b.m("POST").h(headers).b(body);
648
- return b.build();
649
- }, "se_GetLandingZoneCommand");
650
- var se_GetLandingZoneOperationCommand = /* @__PURE__ */ __name(async (input, context) => {
651
- const b = (0, import_core.requestBuilder)(input, context);
652
- const headers = {
653
- "content-type": "application/json"
654
- };
655
- b.bp("/get-landingzone-operation");
656
- let body;
657
- body = JSON.stringify(
658
- (0, import_smithy_client.take)(input, {
659
- operationIdentifier: []
660
- })
661
- );
662
- b.m("POST").h(headers).b(body);
663
- return b.build();
664
- }, "se_GetLandingZoneOperationCommand");
665
- var se_ListBaselinesCommand = /* @__PURE__ */ __name(async (input, context) => {
666
- const b = (0, import_core.requestBuilder)(input, context);
667
- const headers = {
668
- "content-type": "application/json"
669
- };
670
- b.bp("/list-baselines");
671
- let body;
672
- body = JSON.stringify(
673
- (0, import_smithy_client.take)(input, {
674
- maxResults: [],
675
- nextToken: []
676
- })
677
- );
678
- b.m("POST").h(headers).b(body);
679
- return b.build();
680
- }, "se_ListBaselinesCommand");
681
- var se_ListControlOperationsCommand = /* @__PURE__ */ __name(async (input, context) => {
682
- const b = (0, import_core.requestBuilder)(input, context);
683
- const headers = {
684
- "content-type": "application/json"
685
- };
686
- b.bp("/list-control-operations");
687
- let body;
688
- body = JSON.stringify(
689
- (0, import_smithy_client.take)(input, {
690
- filter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "filter"),
691
- maxResults: [],
692
- nextToken: []
693
- })
694
- );
695
- b.m("POST").h(headers).b(body);
696
- return b.build();
697
- }, "se_ListControlOperationsCommand");
698
- var se_ListEnabledBaselinesCommand = /* @__PURE__ */ __name(async (input, context) => {
699
- const b = (0, import_core.requestBuilder)(input, context);
700
- const headers = {
701
- "content-type": "application/json"
702
- };
703
- b.bp("/list-enabled-baselines");
704
- let body;
705
- body = JSON.stringify(
706
- (0, import_smithy_client.take)(input, {
707
- filter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "filter"),
708
- includeChildren: [],
709
- maxResults: [],
710
- nextToken: []
711
- })
712
- );
713
- b.m("POST").h(headers).b(body);
714
- return b.build();
715
- }, "se_ListEnabledBaselinesCommand");
716
- var se_ListEnabledControlsCommand = /* @__PURE__ */ __name(async (input, context) => {
717
- const b = (0, import_core.requestBuilder)(input, context);
718
- const headers = {
719
- "content-type": "application/json"
720
- };
721
- b.bp("/list-enabled-controls");
722
- let body;
723
- body = JSON.stringify(
724
- (0, import_smithy_client.take)(input, {
725
- filter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "filter"),
726
- maxResults: [],
727
- nextToken: [],
728
- targetIdentifier: []
729
- })
730
- );
731
- b.m("POST").h(headers).b(body);
732
- return b.build();
733
- }, "se_ListEnabledControlsCommand");
734
- var se_ListLandingZoneOperationsCommand = /* @__PURE__ */ __name(async (input, context) => {
735
- const b = (0, import_core.requestBuilder)(input, context);
736
- const headers = {
737
- "content-type": "application/json"
738
- };
739
- b.bp("/list-landingzone-operations");
740
- let body;
741
- body = JSON.stringify(
742
- (0, import_smithy_client.take)(input, {
743
- filter: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "filter"),
744
- maxResults: [],
745
- nextToken: []
746
- })
747
- );
748
- b.m("POST").h(headers).b(body);
749
- return b.build();
750
- }, "se_ListLandingZoneOperationsCommand");
751
- var se_ListLandingZonesCommand = /* @__PURE__ */ __name(async (input, context) => {
752
- const b = (0, import_core.requestBuilder)(input, context);
753
- const headers = {
754
- "content-type": "application/json"
755
- };
756
- b.bp("/list-landingzones");
757
- let body;
758
- body = JSON.stringify(
759
- (0, import_smithy_client.take)(input, {
760
- maxResults: [],
761
- nextToken: []
762
- })
763
- );
764
- b.m("POST").h(headers).b(body);
765
- return b.build();
766
- }, "se_ListLandingZonesCommand");
767
- var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
768
- const b = (0, import_core.requestBuilder)(input, context);
769
- const headers = {};
770
- b.bp("/tags/{resourceArn}");
771
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
772
- let body;
773
- b.m("GET").h(headers).b(body);
774
- return b.build();
775
- }, "se_ListTagsForResourceCommand");
776
- var se_ResetEnabledBaselineCommand = /* @__PURE__ */ __name(async (input, context) => {
777
- const b = (0, import_core.requestBuilder)(input, context);
778
- const headers = {
779
- "content-type": "application/json"
780
- };
781
- b.bp("/reset-enabled-baseline");
782
- let body;
783
- body = JSON.stringify(
784
- (0, import_smithy_client.take)(input, {
785
- enabledBaselineIdentifier: []
786
- })
787
- );
788
- b.m("POST").h(headers).b(body);
789
- return b.build();
790
- }, "se_ResetEnabledBaselineCommand");
791
- var se_ResetEnabledControlCommand = /* @__PURE__ */ __name(async (input, context) => {
792
- const b = (0, import_core.requestBuilder)(input, context);
793
- const headers = {
794
- "content-type": "application/json"
795
- };
796
- b.bp("/reset-enabled-control");
797
- let body;
798
- body = JSON.stringify(
799
- (0, import_smithy_client.take)(input, {
800
- enabledControlIdentifier: []
801
- })
802
- );
803
- b.m("POST").h(headers).b(body);
804
- return b.build();
805
- }, "se_ResetEnabledControlCommand");
806
- var se_ResetLandingZoneCommand = /* @__PURE__ */ __name(async (input, context) => {
807
- const b = (0, import_core.requestBuilder)(input, context);
808
- const headers = {
809
- "content-type": "application/json"
810
- };
811
- b.bp("/reset-landingzone");
812
- let body;
813
- body = JSON.stringify(
814
- (0, import_smithy_client.take)(input, {
815
- landingZoneIdentifier: []
816
- })
817
- );
818
- b.m("POST").h(headers).b(body);
819
- return b.build();
820
- }, "se_ResetLandingZoneCommand");
821
- var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
822
- const b = (0, import_core.requestBuilder)(input, context);
823
- const headers = {
824
- "content-type": "application/json"
825
- };
826
- b.bp("/tags/{resourceArn}");
827
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
828
- let body;
829
- body = JSON.stringify(
830
- (0, import_smithy_client.take)(input, {
831
- tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "tags")
832
- })
833
- );
834
- b.m("POST").h(headers).b(body);
835
- return b.build();
836
- }, "se_TagResourceCommand");
837
- var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
838
- const b = (0, import_core.requestBuilder)(input, context);
839
- const headers = {};
840
- b.bp("/tags/{resourceArn}");
841
- b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
842
- const query = (0, import_smithy_client.map)({
843
- [_tK]: [(0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []]
844
- });
845
- let body;
846
- b.m("DELETE").h(headers).q(query).b(body);
847
- return b.build();
848
- }, "se_UntagResourceCommand");
849
- var se_UpdateEnabledBaselineCommand = /* @__PURE__ */ __name(async (input, context) => {
850
- const b = (0, import_core.requestBuilder)(input, context);
851
- const headers = {
852
- "content-type": "application/json"
853
- };
854
- b.bp("/update-enabled-baseline");
855
- let body;
856
- body = JSON.stringify(
857
- (0, import_smithy_client.take)(input, {
858
- baselineVersion: [],
859
- enabledBaselineIdentifier: [],
860
- parameters: /* @__PURE__ */ __name((_) => se_EnabledBaselineParameters(_, context), "parameters")
861
- })
862
- );
863
- b.m("POST").h(headers).b(body);
864
- return b.build();
865
- }, "se_UpdateEnabledBaselineCommand");
866
- var se_UpdateEnabledControlCommand = /* @__PURE__ */ __name(async (input, context) => {
867
- const b = (0, import_core.requestBuilder)(input, context);
868
- const headers = {
869
- "content-type": "application/json"
870
- };
871
- b.bp("/update-enabled-control");
872
- let body;
873
- body = JSON.stringify(
874
- (0, import_smithy_client.take)(input, {
875
- enabledControlIdentifier: [],
876
- parameters: /* @__PURE__ */ __name((_) => se_EnabledControlParameters(_, context), "parameters")
877
- })
878
- );
879
- b.m("POST").h(headers).b(body);
880
- return b.build();
881
- }, "se_UpdateEnabledControlCommand");
882
- var se_UpdateLandingZoneCommand = /* @__PURE__ */ __name(async (input, context) => {
883
- const b = (0, import_core.requestBuilder)(input, context);
884
- const headers = {
885
- "content-type": "application/json"
886
- };
887
- b.bp("/update-landingzone");
888
- let body;
889
- body = JSON.stringify(
890
- (0, import_smithy_client.take)(input, {
891
- landingZoneIdentifier: [],
892
- manifest: /* @__PURE__ */ __name((_) => se_Manifest(_, context), "manifest"),
893
- version: []
894
- })
895
- );
896
- b.m("POST").h(headers).b(body);
897
- return b.build();
898
- }, "se_UpdateLandingZoneCommand");
899
- var de_CreateLandingZoneCommand = /* @__PURE__ */ __name(async (output, context) => {
900
- if (output.statusCode !== 200 && output.statusCode >= 300) {
901
- return de_CommandError(output, context);
902
- }
903
- const contents = (0, import_smithy_client.map)({
904
- $metadata: deserializeMetadata(output)
905
- });
906
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
907
- const doc = (0, import_smithy_client.take)(data, {
908
- arn: import_smithy_client.expectString,
909
- operationIdentifier: import_smithy_client.expectString
910
- });
911
- Object.assign(contents, doc);
912
- return contents;
913
- }, "de_CreateLandingZoneCommand");
914
- var de_DeleteLandingZoneCommand = /* @__PURE__ */ __name(async (output, context) => {
915
- if (output.statusCode !== 200 && output.statusCode >= 300) {
916
- return de_CommandError(output, context);
917
- }
918
- const contents = (0, import_smithy_client.map)({
919
- $metadata: deserializeMetadata(output)
920
- });
921
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
922
- const doc = (0, import_smithy_client.take)(data, {
923
- operationIdentifier: import_smithy_client.expectString
924
- });
925
- Object.assign(contents, doc);
926
- return contents;
927
- }, "de_DeleteLandingZoneCommand");
928
- var de_DisableBaselineCommand = /* @__PURE__ */ __name(async (output, context) => {
929
- if (output.statusCode !== 200 && output.statusCode >= 300) {
930
- return de_CommandError(output, context);
931
- }
932
- const contents = (0, import_smithy_client.map)({
933
- $metadata: deserializeMetadata(output)
934
- });
935
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
936
- const doc = (0, import_smithy_client.take)(data, {
937
- operationIdentifier: import_smithy_client.expectString
938
- });
939
- Object.assign(contents, doc);
940
- return contents;
941
- }, "de_DisableBaselineCommand");
942
- var de_DisableControlCommand = /* @__PURE__ */ __name(async (output, context) => {
943
- if (output.statusCode !== 200 && output.statusCode >= 300) {
944
- return de_CommandError(output, context);
945
- }
946
- const contents = (0, import_smithy_client.map)({
947
- $metadata: deserializeMetadata(output)
948
- });
949
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
950
- const doc = (0, import_smithy_client.take)(data, {
951
- operationIdentifier: import_smithy_client.expectString
952
- });
953
- Object.assign(contents, doc);
954
- return contents;
955
- }, "de_DisableControlCommand");
956
- var de_EnableBaselineCommand = /* @__PURE__ */ __name(async (output, context) => {
957
- if (output.statusCode !== 200 && output.statusCode >= 300) {
958
- return de_CommandError(output, context);
959
- }
960
- const contents = (0, import_smithy_client.map)({
961
- $metadata: deserializeMetadata(output)
962
- });
963
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
964
- const doc = (0, import_smithy_client.take)(data, {
965
- arn: import_smithy_client.expectString,
966
- operationIdentifier: import_smithy_client.expectString
967
- });
968
- Object.assign(contents, doc);
969
- return contents;
970
- }, "de_EnableBaselineCommand");
971
- var de_EnableControlCommand = /* @__PURE__ */ __name(async (output, context) => {
972
- if (output.statusCode !== 200 && output.statusCode >= 300) {
973
- return de_CommandError(output, context);
974
- }
975
- const contents = (0, import_smithy_client.map)({
976
- $metadata: deserializeMetadata(output)
977
- });
978
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
979
- const doc = (0, import_smithy_client.take)(data, {
980
- arn: import_smithy_client.expectString,
981
- operationIdentifier: import_smithy_client.expectString
982
- });
983
- Object.assign(contents, doc);
984
- return contents;
985
- }, "de_EnableControlCommand");
986
- var de_GetBaselineCommand = /* @__PURE__ */ __name(async (output, context) => {
987
- if (output.statusCode !== 200 && output.statusCode >= 300) {
988
- return de_CommandError(output, context);
989
- }
990
- const contents = (0, import_smithy_client.map)({
991
- $metadata: deserializeMetadata(output)
992
- });
993
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
994
- const doc = (0, import_smithy_client.take)(data, {
995
- arn: import_smithy_client.expectString,
996
- description: import_smithy_client.expectString,
997
- name: import_smithy_client.expectString
998
- });
999
- Object.assign(contents, doc);
1000
- return contents;
1001
- }, "de_GetBaselineCommand");
1002
- var de_GetBaselineOperationCommand = /* @__PURE__ */ __name(async (output, context) => {
1003
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1004
- return de_CommandError(output, context);
1005
- }
1006
- const contents = (0, import_smithy_client.map)({
1007
- $metadata: deserializeMetadata(output)
1008
- });
1009
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1010
- const doc = (0, import_smithy_client.take)(data, {
1011
- baselineOperation: /* @__PURE__ */ __name((_) => de_BaselineOperation(_, context), "baselineOperation")
1012
- });
1013
- Object.assign(contents, doc);
1014
- return contents;
1015
- }, "de_GetBaselineOperationCommand");
1016
- var de_GetControlOperationCommand = /* @__PURE__ */ __name(async (output, context) => {
1017
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1018
- return de_CommandError(output, context);
1019
- }
1020
- const contents = (0, import_smithy_client.map)({
1021
- $metadata: deserializeMetadata(output)
1022
- });
1023
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1024
- const doc = (0, import_smithy_client.take)(data, {
1025
- controlOperation: /* @__PURE__ */ __name((_) => de_ControlOperation(_, context), "controlOperation")
1026
- });
1027
- Object.assign(contents, doc);
1028
- return contents;
1029
- }, "de_GetControlOperationCommand");
1030
- var de_GetEnabledBaselineCommand = /* @__PURE__ */ __name(async (output, context) => {
1031
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1032
- return de_CommandError(output, context);
1033
- }
1034
- const contents = (0, import_smithy_client.map)({
1035
- $metadata: deserializeMetadata(output)
1036
- });
1037
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1038
- const doc = (0, import_smithy_client.take)(data, {
1039
- enabledBaselineDetails: /* @__PURE__ */ __name((_) => de_EnabledBaselineDetails(_, context), "enabledBaselineDetails")
1040
- });
1041
- Object.assign(contents, doc);
1042
- return contents;
1043
- }, "de_GetEnabledBaselineCommand");
1044
- var de_GetEnabledControlCommand = /* @__PURE__ */ __name(async (output, context) => {
1045
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1046
- return de_CommandError(output, context);
1047
- }
1048
- const contents = (0, import_smithy_client.map)({
1049
- $metadata: deserializeMetadata(output)
1050
- });
1051
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1052
- const doc = (0, import_smithy_client.take)(data, {
1053
- enabledControlDetails: /* @__PURE__ */ __name((_) => de_EnabledControlDetails(_, context), "enabledControlDetails")
1054
- });
1055
- Object.assign(contents, doc);
1056
- return contents;
1057
- }, "de_GetEnabledControlCommand");
1058
- var de_GetLandingZoneCommand = /* @__PURE__ */ __name(async (output, context) => {
1059
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1060
- return de_CommandError(output, context);
1061
- }
1062
- const contents = (0, import_smithy_client.map)({
1063
- $metadata: deserializeMetadata(output)
1064
- });
1065
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1066
- const doc = (0, import_smithy_client.take)(data, {
1067
- landingZone: /* @__PURE__ */ __name((_) => de_LandingZoneDetail(_, context), "landingZone")
1068
- });
1069
- Object.assign(contents, doc);
1070
- return contents;
1071
- }, "de_GetLandingZoneCommand");
1072
- var de_GetLandingZoneOperationCommand = /* @__PURE__ */ __name(async (output, context) => {
1073
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1074
- return de_CommandError(output, context);
1075
- }
1076
- const contents = (0, import_smithy_client.map)({
1077
- $metadata: deserializeMetadata(output)
1078
- });
1079
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1080
- const doc = (0, import_smithy_client.take)(data, {
1081
- operationDetails: /* @__PURE__ */ __name((_) => de_LandingZoneOperationDetail(_, context), "operationDetails")
1082
- });
1083
- Object.assign(contents, doc);
1084
- return contents;
1085
- }, "de_GetLandingZoneOperationCommand");
1086
- var de_ListBaselinesCommand = /* @__PURE__ */ __name(async (output, context) => {
1087
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1088
- return de_CommandError(output, context);
1089
- }
1090
- const contents = (0, import_smithy_client.map)({
1091
- $metadata: deserializeMetadata(output)
1092
- });
1093
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1094
- const doc = (0, import_smithy_client.take)(data, {
1095
- baselines: import_smithy_client._json,
1096
- nextToken: import_smithy_client.expectString
1097
- });
1098
- Object.assign(contents, doc);
1099
- return contents;
1100
- }, "de_ListBaselinesCommand");
1101
- var de_ListControlOperationsCommand = /* @__PURE__ */ __name(async (output, context) => {
1102
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1103
- return de_CommandError(output, context);
1104
- }
1105
- const contents = (0, import_smithy_client.map)({
1106
- $metadata: deserializeMetadata(output)
1107
- });
1108
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1109
- const doc = (0, import_smithy_client.take)(data, {
1110
- controlOperations: /* @__PURE__ */ __name((_) => de_ControlOperations(_, context), "controlOperations"),
1111
- nextToken: import_smithy_client.expectString
1112
- });
1113
- Object.assign(contents, doc);
1114
- return contents;
1115
- }, "de_ListControlOperationsCommand");
1116
- var de_ListEnabledBaselinesCommand = /* @__PURE__ */ __name(async (output, context) => {
1117
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1118
- return de_CommandError(output, context);
1119
- }
1120
- const contents = (0, import_smithy_client.map)({
1121
- $metadata: deserializeMetadata(output)
1122
- });
1123
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1124
- const doc = (0, import_smithy_client.take)(data, {
1125
- enabledBaselines: import_smithy_client._json,
1126
- nextToken: import_smithy_client.expectString
1127
- });
1128
- Object.assign(contents, doc);
1129
- return contents;
1130
- }, "de_ListEnabledBaselinesCommand");
1131
- var de_ListEnabledControlsCommand = /* @__PURE__ */ __name(async (output, context) => {
1132
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1133
- return de_CommandError(output, context);
1134
- }
1135
- const contents = (0, import_smithy_client.map)({
1136
- $metadata: deserializeMetadata(output)
1137
- });
1138
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1139
- const doc = (0, import_smithy_client.take)(data, {
1140
- enabledControls: import_smithy_client._json,
1141
- nextToken: import_smithy_client.expectString
1142
- });
1143
- Object.assign(contents, doc);
1144
- return contents;
1145
- }, "de_ListEnabledControlsCommand");
1146
- var de_ListLandingZoneOperationsCommand = /* @__PURE__ */ __name(async (output, context) => {
1147
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1148
- return de_CommandError(output, context);
1149
- }
1150
- const contents = (0, import_smithy_client.map)({
1151
- $metadata: deserializeMetadata(output)
1152
- });
1153
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1154
- const doc = (0, import_smithy_client.take)(data, {
1155
- landingZoneOperations: import_smithy_client._json,
1156
- nextToken: import_smithy_client.expectString
1157
- });
1158
- Object.assign(contents, doc);
1159
- return contents;
1160
- }, "de_ListLandingZoneOperationsCommand");
1161
- var de_ListLandingZonesCommand = /* @__PURE__ */ __name(async (output, context) => {
1162
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1163
- return de_CommandError(output, context);
1164
- }
1165
- const contents = (0, import_smithy_client.map)({
1166
- $metadata: deserializeMetadata(output)
1167
- });
1168
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1169
- const doc = (0, import_smithy_client.take)(data, {
1170
- landingZones: import_smithy_client._json,
1171
- nextToken: import_smithy_client.expectString
1172
- });
1173
- Object.assign(contents, doc);
1174
- return contents;
1175
- }, "de_ListLandingZonesCommand");
1176
- var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1177
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1178
- return de_CommandError(output, context);
1179
- }
1180
- const contents = (0, import_smithy_client.map)({
1181
- $metadata: deserializeMetadata(output)
1182
- });
1183
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1184
- const doc = (0, import_smithy_client.take)(data, {
1185
- tags: import_smithy_client._json
1186
- });
1187
- Object.assign(contents, doc);
1188
- return contents;
1189
- }, "de_ListTagsForResourceCommand");
1190
- var de_ResetEnabledBaselineCommand = /* @__PURE__ */ __name(async (output, context) => {
1191
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1192
- return de_CommandError(output, context);
1193
- }
1194
- const contents = (0, import_smithy_client.map)({
1195
- $metadata: deserializeMetadata(output)
1196
- });
1197
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1198
- const doc = (0, import_smithy_client.take)(data, {
1199
- operationIdentifier: import_smithy_client.expectString
1200
- });
1201
- Object.assign(contents, doc);
1202
- return contents;
1203
- }, "de_ResetEnabledBaselineCommand");
1204
- var de_ResetEnabledControlCommand = /* @__PURE__ */ __name(async (output, context) => {
1205
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1206
- return de_CommandError(output, context);
1207
- }
1208
- const contents = (0, import_smithy_client.map)({
1209
- $metadata: deserializeMetadata(output)
1210
- });
1211
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1212
- const doc = (0, import_smithy_client.take)(data, {
1213
- operationIdentifier: import_smithy_client.expectString
1214
- });
1215
- Object.assign(contents, doc);
1216
- return contents;
1217
- }, "de_ResetEnabledControlCommand");
1218
- var de_ResetLandingZoneCommand = /* @__PURE__ */ __name(async (output, context) => {
1219
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1220
- return de_CommandError(output, context);
1221
- }
1222
- const contents = (0, import_smithy_client.map)({
1223
- $metadata: deserializeMetadata(output)
1224
- });
1225
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1226
- const doc = (0, import_smithy_client.take)(data, {
1227
- operationIdentifier: import_smithy_client.expectString
1228
- });
1229
- Object.assign(contents, doc);
1230
- return contents;
1231
- }, "de_ResetLandingZoneCommand");
1232
- var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1233
- if (output.statusCode !== 204 && output.statusCode >= 300) {
1234
- return de_CommandError(output, context);
1235
- }
1236
- const contents = (0, import_smithy_client.map)({
1237
- $metadata: deserializeMetadata(output)
1238
- });
1239
- await (0, import_smithy_client.collectBody)(output.body, context);
1240
- return contents;
1241
- }, "de_TagResourceCommand");
1242
- var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1243
- if (output.statusCode !== 204 && output.statusCode >= 300) {
1244
- return de_CommandError(output, context);
1245
- }
1246
- const contents = (0, import_smithy_client.map)({
1247
- $metadata: deserializeMetadata(output)
1248
- });
1249
- await (0, import_smithy_client.collectBody)(output.body, context);
1250
- return contents;
1251
- }, "de_UntagResourceCommand");
1252
- var de_UpdateEnabledBaselineCommand = /* @__PURE__ */ __name(async (output, context) => {
1253
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1254
- return de_CommandError(output, context);
1255
- }
1256
- const contents = (0, import_smithy_client.map)({
1257
- $metadata: deserializeMetadata(output)
1258
- });
1259
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1260
- const doc = (0, import_smithy_client.take)(data, {
1261
- operationIdentifier: import_smithy_client.expectString
1262
- });
1263
- Object.assign(contents, doc);
1264
- return contents;
1265
- }, "de_UpdateEnabledBaselineCommand");
1266
- var de_UpdateEnabledControlCommand = /* @__PURE__ */ __name(async (output, context) => {
1267
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1268
- return de_CommandError(output, context);
1269
- }
1270
- const contents = (0, import_smithy_client.map)({
1271
- $metadata: deserializeMetadata(output)
1272
- });
1273
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1274
- const doc = (0, import_smithy_client.take)(data, {
1275
- operationIdentifier: import_smithy_client.expectString
1276
- });
1277
- Object.assign(contents, doc);
1278
- return contents;
1279
- }, "de_UpdateEnabledControlCommand");
1280
- var de_UpdateLandingZoneCommand = /* @__PURE__ */ __name(async (output, context) => {
1281
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1282
- return de_CommandError(output, context);
1283
- }
1284
- const contents = (0, import_smithy_client.map)({
1285
- $metadata: deserializeMetadata(output)
1286
- });
1287
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1288
- const doc = (0, import_smithy_client.take)(data, {
1289
- operationIdentifier: import_smithy_client.expectString
1290
- });
1291
- Object.assign(contents, doc);
1292
- return contents;
1293
- }, "de_UpdateLandingZoneCommand");
1294
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
1295
- const parsedOutput = {
1296
- ...output,
1297
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
1298
- };
1299
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
1300
- switch (errorCode) {
1301
- case "AccessDeniedException":
1302
- case "com.amazonaws.controltower#AccessDeniedException":
1303
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1304
- case "ConflictException":
1305
- case "com.amazonaws.controltower#ConflictException":
1306
- throw await de_ConflictExceptionRes(parsedOutput, context);
1307
- case "InternalServerException":
1308
- case "com.amazonaws.controltower#InternalServerException":
1309
- throw await de_InternalServerExceptionRes(parsedOutput, context);
1310
- case "ThrottlingException":
1311
- case "com.amazonaws.controltower#ThrottlingException":
1312
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
1313
- case "ValidationException":
1314
- case "com.amazonaws.controltower#ValidationException":
1315
- throw await de_ValidationExceptionRes(parsedOutput, context);
1316
- case "ResourceNotFoundException":
1317
- case "com.amazonaws.controltower#ResourceNotFoundException":
1318
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1319
- case "ServiceQuotaExceededException":
1320
- case "com.amazonaws.controltower#ServiceQuotaExceededException":
1321
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
1322
- default:
1323
- const parsedBody = parsedOutput.body;
1324
- return throwDefaultError({
1325
- output,
1326
- parsedBody,
1327
- errorCode
1328
- });
1329
- }
1330
- }, "de_CommandError");
1331
- var throwDefaultError = (0, import_smithy_client.withBaseException)(ControlTowerServiceException);
1332
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1333
- const contents = (0, import_smithy_client.map)({});
1334
- const data = parsedOutput.body;
1335
- const doc = (0, import_smithy_client.take)(data, {
1336
- message: import_smithy_client.expectString
1337
- });
1338
- Object.assign(contents, doc);
1339
- const exception = new AccessDeniedException({
1340
- $metadata: deserializeMetadata(parsedOutput),
1341
- ...contents
1342
- });
1343
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1344
- }, "de_AccessDeniedExceptionRes");
1345
- var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1346
- const contents = (0, import_smithy_client.map)({});
1347
- const data = parsedOutput.body;
1348
- const doc = (0, import_smithy_client.take)(data, {
1349
- message: import_smithy_client.expectString
1350
- });
1351
- Object.assign(contents, doc);
1352
- const exception = new ConflictException({
1353
- $metadata: deserializeMetadata(parsedOutput),
1354
- ...contents
1355
- });
1356
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1357
- }, "de_ConflictExceptionRes");
1358
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1359
- const contents = (0, import_smithy_client.map)({});
1360
- const data = parsedOutput.body;
1361
- const doc = (0, import_smithy_client.take)(data, {
1362
- message: import_smithy_client.expectString
1363
- });
1364
- Object.assign(contents, doc);
1365
- const exception = new InternalServerException({
1366
- $metadata: deserializeMetadata(parsedOutput),
1367
- ...contents
1368
- });
1369
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1370
- }, "de_InternalServerExceptionRes");
1371
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1372
- const contents = (0, import_smithy_client.map)({});
1373
- const data = parsedOutput.body;
1374
- const doc = (0, import_smithy_client.take)(data, {
1375
- message: import_smithy_client.expectString
1376
- });
1377
- Object.assign(contents, doc);
1378
- const exception = new ResourceNotFoundException({
1379
- $metadata: deserializeMetadata(parsedOutput),
1380
- ...contents
1381
- });
1382
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1383
- }, "de_ResourceNotFoundExceptionRes");
1384
- var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1385
- const contents = (0, import_smithy_client.map)({});
1386
- const data = parsedOutput.body;
1387
- const doc = (0, import_smithy_client.take)(data, {
1388
- message: import_smithy_client.expectString
1389
- });
1390
- Object.assign(contents, doc);
1391
- const exception = new ServiceQuotaExceededException({
1392
- $metadata: deserializeMetadata(parsedOutput),
1393
- ...contents
1394
- });
1395
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1396
- }, "de_ServiceQuotaExceededExceptionRes");
1397
- var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1398
- const contents = (0, import_smithy_client.map)({
1399
- [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
1400
- });
1401
- const data = parsedOutput.body;
1402
- const doc = (0, import_smithy_client.take)(data, {
1403
- message: import_smithy_client.expectString,
1404
- quotaCode: import_smithy_client.expectString,
1405
- serviceCode: import_smithy_client.expectString
1406
- });
1407
- Object.assign(contents, doc);
1408
- const exception = new ThrottlingException({
1409
- $metadata: deserializeMetadata(parsedOutput),
1410
- ...contents
1411
- });
1412
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1413
- }, "de_ThrottlingExceptionRes");
1414
- var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1415
- const contents = (0, import_smithy_client.map)({});
1416
- const data = parsedOutput.body;
1417
- const doc = (0, import_smithy_client.take)(data, {
1418
- message: import_smithy_client.expectString
1419
- });
1420
- Object.assign(contents, doc);
1421
- const exception = new ValidationException({
1422
- $metadata: deserializeMetadata(parsedOutput),
1423
- ...contents
1424
- });
1425
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1426
- }, "de_ValidationExceptionRes");
1427
- var se_EnabledBaselineParameter = /* @__PURE__ */ __name((input, context) => {
1428
- return (0, import_smithy_client.take)(input, {
1429
- key: [],
1430
- value: /* @__PURE__ */ __name((_) => se_EnabledBaselineParameterDocument(_, context), "value")
1431
- });
1432
- }, "se_EnabledBaselineParameter");
1433
- var se_EnabledBaselineParameterDocument = /* @__PURE__ */ __name((input, context) => {
1434
- return input;
1435
- }, "se_EnabledBaselineParameterDocument");
1436
- var se_EnabledBaselineParameters = /* @__PURE__ */ __name((input, context) => {
1437
- return input.filter((e) => e != null).map((entry) => {
1438
- return se_EnabledBaselineParameter(entry, context);
1439
- });
1440
- }, "se_EnabledBaselineParameters");
1441
- var se_EnabledControlParameter = /* @__PURE__ */ __name((input, context) => {
1442
- return (0, import_smithy_client.take)(input, {
1443
- key: [],
1444
- value: /* @__PURE__ */ __name((_) => se_Document(_, context), "value")
1445
- });
1446
- }, "se_EnabledControlParameter");
1447
- var se_EnabledControlParameters = /* @__PURE__ */ __name((input, context) => {
1448
- return input.filter((e) => e != null).map((entry) => {
1449
- return se_EnabledControlParameter(entry, context);
1450
- });
1451
- }, "se_EnabledControlParameters");
1452
- var se_Manifest = /* @__PURE__ */ __name((input, context) => {
1453
- return input;
1454
- }, "se_Manifest");
1455
- var se_Document = /* @__PURE__ */ __name((input, context) => {
1456
- return input;
1457
- }, "se_Document");
1458
- var de_BaselineOperation = /* @__PURE__ */ __name((output, context) => {
1459
- return (0, import_smithy_client.take)(output, {
1460
- endTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "endTime"),
1461
- operationIdentifier: import_smithy_client.expectString,
1462
- operationType: import_smithy_client.expectString,
1463
- startTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "startTime"),
1464
- status: import_smithy_client.expectString,
1465
- statusMessage: import_smithy_client.expectString
1466
- });
1467
- }, "de_BaselineOperation");
1468
- var de_ControlOperation = /* @__PURE__ */ __name((output, context) => {
1469
- return (0, import_smithy_client.take)(output, {
1470
- controlIdentifier: import_smithy_client.expectString,
1471
- enabledControlIdentifier: import_smithy_client.expectString,
1472
- endTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "endTime"),
1473
- operationIdentifier: import_smithy_client.expectString,
1474
- operationType: import_smithy_client.expectString,
1475
- startTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "startTime"),
1476
- status: import_smithy_client.expectString,
1477
- statusMessage: import_smithy_client.expectString,
1478
- targetIdentifier: import_smithy_client.expectString
1479
- });
1480
- }, "de_ControlOperation");
1481
- var de_ControlOperations = /* @__PURE__ */ __name((output, context) => {
1482
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1483
- return de_ControlOperationSummary(entry, context);
1484
- });
1485
- return retVal;
1486
- }, "de_ControlOperations");
1487
- var de_ControlOperationSummary = /* @__PURE__ */ __name((output, context) => {
1488
- return (0, import_smithy_client.take)(output, {
1489
- controlIdentifier: import_smithy_client.expectString,
1490
- enabledControlIdentifier: import_smithy_client.expectString,
1491
- endTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "endTime"),
1492
- operationIdentifier: import_smithy_client.expectString,
1493
- operationType: import_smithy_client.expectString,
1494
- startTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "startTime"),
1495
- status: import_smithy_client.expectString,
1496
- statusMessage: import_smithy_client.expectString,
1497
- targetIdentifier: import_smithy_client.expectString
1498
- });
1499
- }, "de_ControlOperationSummary");
1500
- var de_EnabledBaselineDetails = /* @__PURE__ */ __name((output, context) => {
1501
- return (0, import_smithy_client.take)(output, {
1502
- arn: import_smithy_client.expectString,
1503
- baselineIdentifier: import_smithy_client.expectString,
1504
- baselineVersion: import_smithy_client.expectString,
1505
- driftStatusSummary: import_smithy_client._json,
1506
- parameters: /* @__PURE__ */ __name((_) => de_EnabledBaselineParameterSummaries(_, context), "parameters"),
1507
- parentIdentifier: import_smithy_client.expectString,
1508
- statusSummary: import_smithy_client._json,
1509
- targetIdentifier: import_smithy_client.expectString
1510
- });
1511
- }, "de_EnabledBaselineDetails");
1512
- var de_EnabledBaselineParameterDocument = /* @__PURE__ */ __name((output, context) => {
1513
- return output;
1514
- }, "de_EnabledBaselineParameterDocument");
1515
- var de_EnabledBaselineParameterSummaries = /* @__PURE__ */ __name((output, context) => {
1516
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1517
- return de_EnabledBaselineParameterSummary(entry, context);
1518
- });
1519
- return retVal;
1520
- }, "de_EnabledBaselineParameterSummaries");
1521
- var de_EnabledBaselineParameterSummary = /* @__PURE__ */ __name((output, context) => {
1522
- return (0, import_smithy_client.take)(output, {
1523
- key: import_smithy_client.expectString,
1524
- value: /* @__PURE__ */ __name((_) => de_EnabledBaselineParameterDocument(_, context), "value")
1525
- });
1526
- }, "de_EnabledBaselineParameterSummary");
1527
- var de_EnabledControlDetails = /* @__PURE__ */ __name((output, context) => {
1528
- return (0, import_smithy_client.take)(output, {
1529
- arn: import_smithy_client.expectString,
1530
- controlIdentifier: import_smithy_client.expectString,
1531
- driftStatusSummary: import_smithy_client._json,
1532
- parameters: /* @__PURE__ */ __name((_) => de_EnabledControlParameterSummaries(_, context), "parameters"),
1533
- statusSummary: import_smithy_client._json,
1534
- targetIdentifier: import_smithy_client.expectString,
1535
- targetRegions: import_smithy_client._json
1536
- });
1537
- }, "de_EnabledControlDetails");
1538
- var de_EnabledControlParameterSummaries = /* @__PURE__ */ __name((output, context) => {
1539
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1540
- return de_EnabledControlParameterSummary(entry, context);
1541
- });
1542
- return retVal;
1543
- }, "de_EnabledControlParameterSummaries");
1544
- var de_EnabledControlParameterSummary = /* @__PURE__ */ __name((output, context) => {
1545
- return (0, import_smithy_client.take)(output, {
1546
- key: import_smithy_client.expectString,
1547
- value: /* @__PURE__ */ __name((_) => de_Document(_, context), "value")
1548
- });
1549
- }, "de_EnabledControlParameterSummary");
1550
- var de_LandingZoneDetail = /* @__PURE__ */ __name((output, context) => {
1551
- return (0, import_smithy_client.take)(output, {
1552
- arn: import_smithy_client.expectString,
1553
- driftStatus: import_smithy_client._json,
1554
- latestAvailableVersion: import_smithy_client.expectString,
1555
- manifest: /* @__PURE__ */ __name((_) => de_Manifest(_, context), "manifest"),
1556
- status: import_smithy_client.expectString,
1557
- version: import_smithy_client.expectString
1558
- });
1559
- }, "de_LandingZoneDetail");
1560
- var de_LandingZoneOperationDetail = /* @__PURE__ */ __name((output, context) => {
1561
- return (0, import_smithy_client.take)(output, {
1562
- endTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "endTime"),
1563
- operationIdentifier: import_smithy_client.expectString,
1564
- operationType: import_smithy_client.expectString,
1565
- startTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "startTime"),
1566
- status: import_smithy_client.expectString,
1567
- statusMessage: import_smithy_client.expectString
1568
- });
1569
- }, "de_LandingZoneOperationDetail");
1570
- var de_Manifest = /* @__PURE__ */ __name((output, context) => {
1571
- return output;
1572
- }, "de_Manifest");
1573
- var de_Document = /* @__PURE__ */ __name((output, context) => {
1574
- return output;
1575
- }, "de_Document");
1576
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1577
- httpStatusCode: output.statusCode,
1578
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1579
- extendedRequestId: output.headers["x-amz-id-2"],
1580
- cfId: output.headers["x-amz-cf-id"]
1581
- }), "deserializeMetadata");
1582
- var _rAS = "retryAfterSeconds";
1583
- var _ra = "retry-after";
1584
- var _tK = "tagKeys";
1585
-
1586
- // src/commands/CreateLandingZoneCommand.ts
1587
- var CreateLandingZoneCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1588
- return [
1589
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1590
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1591
- ];
1592
- }).s("AWSControlTowerApis", "CreateLandingZone", {}).n("ControlTowerClient", "CreateLandingZoneCommand").f(void 0, void 0).ser(se_CreateLandingZoneCommand).de(de_CreateLandingZoneCommand).build() {
1593
- static {
1594
- __name(this, "CreateLandingZoneCommand");
1595
- }
207
+ const ControlOperationStatus = {
208
+ FAILED: "FAILED",
209
+ IN_PROGRESS: "IN_PROGRESS",
210
+ SUCCEEDED: "SUCCEEDED",
1596
211
  };
1597
-
1598
- // src/commands/DeleteLandingZoneCommand.ts
1599
-
1600
-
1601
-
1602
- var DeleteLandingZoneCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1603
- return [
1604
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1605
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1606
- ];
1607
- }).s("AWSControlTowerApis", "DeleteLandingZone", {}).n("ControlTowerClient", "DeleteLandingZoneCommand").f(void 0, void 0).ser(se_DeleteLandingZoneCommand).de(de_DeleteLandingZoneCommand).build() {
1608
- static {
1609
- __name(this, "DeleteLandingZoneCommand");
1610
- }
212
+ class ConflictException extends ControlTowerServiceException {
213
+ name = "ConflictException";
214
+ $fault = "client";
215
+ constructor(opts) {
216
+ super({
217
+ name: "ConflictException",
218
+ $fault: "client",
219
+ ...opts,
220
+ });
221
+ Object.setPrototypeOf(this, ConflictException.prototype);
222
+ }
223
+ }
224
+ class ServiceQuotaExceededException extends ControlTowerServiceException {
225
+ name = "ServiceQuotaExceededException";
226
+ $fault = "client";
227
+ constructor(opts) {
228
+ super({
229
+ name: "ServiceQuotaExceededException",
230
+ $fault: "client",
231
+ ...opts,
232
+ });
233
+ Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
234
+ }
235
+ }
236
+ const EnabledBaselineDriftStatus = {
237
+ DRIFTED: "DRIFTED",
238
+ IN_SYNC: "IN_SYNC",
1611
239
  };
1612
-
1613
- // src/commands/DisableBaselineCommand.ts
1614
-
1615
-
1616
-
1617
- var DisableBaselineCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1618
- return [
1619
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1620
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1621
- ];
1622
- }).s("AWSControlTowerApis", "DisableBaseline", {}).n("ControlTowerClient", "DisableBaselineCommand").f(void 0, void 0).ser(se_DisableBaselineCommand).de(de_DisableBaselineCommand).build() {
1623
- static {
1624
- __name(this, "DisableBaselineCommand");
1625
- }
240
+ const EnablementStatus = {
241
+ FAILED: "FAILED",
242
+ SUCCEEDED: "SUCCEEDED",
243
+ UNDER_CHANGE: "UNDER_CHANGE",
1626
244
  };
1627
-
1628
- // src/commands/DisableControlCommand.ts
1629
-
1630
-
1631
-
1632
- var DisableControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1633
- return [
1634
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1635
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1636
- ];
1637
- }).s("AWSControlTowerApis", "DisableControl", {}).n("ControlTowerClient", "DisableControlCommand").f(void 0, void 0).ser(se_DisableControlCommand).de(de_DisableControlCommand).build() {
1638
- static {
1639
- __name(this, "DisableControlCommand");
1640
- }
245
+ const DriftStatus = {
246
+ DRIFTED: "DRIFTED",
247
+ IN_SYNC: "IN_SYNC",
248
+ NOT_CHECKING: "NOT_CHECKING",
249
+ UNKNOWN: "UNKNOWN",
1641
250
  };
1642
-
1643
- // src/commands/EnableBaselineCommand.ts
1644
-
1645
-
1646
-
1647
- var EnableBaselineCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1648
- return [
1649
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1650
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1651
- ];
1652
- }).s("AWSControlTowerApis", "EnableBaseline", {}).n("ControlTowerClient", "EnableBaselineCommand").f(void 0, void 0).ser(se_EnableBaselineCommand).de(de_EnableBaselineCommand).build() {
1653
- static {
1654
- __name(this, "EnableBaselineCommand");
1655
- }
251
+ const LandingZoneOperationType = {
252
+ CREATE: "CREATE",
253
+ DELETE: "DELETE",
254
+ RESET: "RESET",
255
+ UPDATE: "UPDATE",
1656
256
  };
1657
-
1658
- // src/commands/EnableControlCommand.ts
1659
-
1660
-
1661
-
1662
- var EnableControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1663
- return [
1664
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1665
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1666
- ];
1667
- }).s("AWSControlTowerApis", "EnableControl", {}).n("ControlTowerClient", "EnableControlCommand").f(void 0, void 0).ser(se_EnableControlCommand).de(de_EnableControlCommand).build() {
1668
- static {
1669
- __name(this, "EnableControlCommand");
1670
- }
257
+ const LandingZoneOperationStatus = {
258
+ FAILED: "FAILED",
259
+ IN_PROGRESS: "IN_PROGRESS",
260
+ SUCCEEDED: "SUCCEEDED",
1671
261
  };
1672
-
1673
- // src/commands/GetBaselineCommand.ts
1674
-
1675
-
1676
-
1677
- var GetBaselineCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1678
- return [
1679
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1680
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1681
- ];
1682
- }).s("AWSControlTowerApis", "GetBaseline", {}).n("ControlTowerClient", "GetBaselineCommand").f(void 0, void 0).ser(se_GetBaselineCommand).de(de_GetBaselineCommand).build() {
1683
- static {
1684
- __name(this, "GetBaselineCommand");
1685
- }
262
+ const LandingZoneDriftStatus = {
263
+ DRIFTED: "DRIFTED",
264
+ IN_SYNC: "IN_SYNC",
1686
265
  };
1687
-
1688
- // src/commands/GetBaselineOperationCommand.ts
1689
-
1690
-
1691
-
1692
- var GetBaselineOperationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1693
- return [
1694
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1695
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1696
- ];
1697
- }).s("AWSControlTowerApis", "GetBaselineOperation", {}).n("ControlTowerClient", "GetBaselineOperationCommand").f(void 0, void 0).ser(se_GetBaselineOperationCommand).de(de_GetBaselineOperationCommand).build() {
1698
- static {
1699
- __name(this, "GetBaselineOperationCommand");
1700
- }
266
+ const LandingZoneStatus = {
267
+ ACTIVE: "ACTIVE",
268
+ FAILED: "FAILED",
269
+ PROCESSING: "PROCESSING",
1701
270
  };
1702
271
 
1703
- // src/commands/GetControlOperationCommand.ts
1704
-
1705
-
1706
-
1707
- var GetControlOperationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1708
- return [
1709
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1710
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1711
- ];
1712
- }).s("AWSControlTowerApis", "GetControlOperation", {}).n("ControlTowerClient", "GetControlOperationCommand").f(void 0, void 0).ser(se_GetControlOperationCommand).de(de_GetControlOperationCommand).build() {
1713
- static {
1714
- __name(this, "GetControlOperationCommand");
1715
- }
272
+ const se_CreateLandingZoneCommand = async (input, context) => {
273
+ const b = core.requestBuilder(input, context);
274
+ const headers = {
275
+ "content-type": "application/json",
276
+ };
277
+ b.bp("/create-landingzone");
278
+ let body;
279
+ body = JSON.stringify(smithyClient.take(input, {
280
+ manifest: (_) => se_Manifest(_),
281
+ tags: (_) => smithyClient._json(_),
282
+ version: [],
283
+ }));
284
+ b.m("POST").h(headers).b(body);
285
+ return b.build();
1716
286
  };
1717
-
1718
- // src/commands/GetEnabledBaselineCommand.ts
1719
-
1720
-
1721
-
1722
- var GetEnabledBaselineCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1723
- return [
1724
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1725
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1726
- ];
1727
- }).s("AWSControlTowerApis", "GetEnabledBaseline", {}).n("ControlTowerClient", "GetEnabledBaselineCommand").f(void 0, void 0).ser(se_GetEnabledBaselineCommand).de(de_GetEnabledBaselineCommand).build() {
1728
- static {
1729
- __name(this, "GetEnabledBaselineCommand");
1730
- }
287
+ const se_DeleteLandingZoneCommand = async (input, context) => {
288
+ const b = core.requestBuilder(input, context);
289
+ const headers = {
290
+ "content-type": "application/json",
291
+ };
292
+ b.bp("/delete-landingzone");
293
+ let body;
294
+ body = JSON.stringify(smithyClient.take(input, {
295
+ landingZoneIdentifier: [],
296
+ }));
297
+ b.m("POST").h(headers).b(body);
298
+ return b.build();
1731
299
  };
1732
-
1733
- // src/commands/GetEnabledControlCommand.ts
1734
-
1735
-
1736
-
1737
- var GetEnabledControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1738
- return [
1739
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1740
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1741
- ];
1742
- }).s("AWSControlTowerApis", "GetEnabledControl", {}).n("ControlTowerClient", "GetEnabledControlCommand").f(void 0, void 0).ser(se_GetEnabledControlCommand).de(de_GetEnabledControlCommand).build() {
1743
- static {
1744
- __name(this, "GetEnabledControlCommand");
1745
- }
300
+ const se_DisableBaselineCommand = async (input, context) => {
301
+ const b = core.requestBuilder(input, context);
302
+ const headers = {
303
+ "content-type": "application/json",
304
+ };
305
+ b.bp("/disable-baseline");
306
+ let body;
307
+ body = JSON.stringify(smithyClient.take(input, {
308
+ enabledBaselineIdentifier: [],
309
+ }));
310
+ b.m("POST").h(headers).b(body);
311
+ return b.build();
1746
312
  };
1747
-
1748
- // src/commands/GetLandingZoneCommand.ts
1749
-
1750
-
1751
-
1752
- var GetLandingZoneCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1753
- return [
1754
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1755
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1756
- ];
1757
- }).s("AWSControlTowerApis", "GetLandingZone", {}).n("ControlTowerClient", "GetLandingZoneCommand").f(void 0, void 0).ser(se_GetLandingZoneCommand).de(de_GetLandingZoneCommand).build() {
1758
- static {
1759
- __name(this, "GetLandingZoneCommand");
1760
- }
313
+ const se_DisableControlCommand = async (input, context) => {
314
+ const b = core.requestBuilder(input, context);
315
+ const headers = {
316
+ "content-type": "application/json",
317
+ };
318
+ b.bp("/disable-control");
319
+ let body;
320
+ body = JSON.stringify(smithyClient.take(input, {
321
+ controlIdentifier: [],
322
+ targetIdentifier: [],
323
+ }));
324
+ b.m("POST").h(headers).b(body);
325
+ return b.build();
1761
326
  };
1762
-
1763
- // src/commands/GetLandingZoneOperationCommand.ts
1764
-
1765
-
1766
-
1767
- var GetLandingZoneOperationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1768
- return [
1769
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1770
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1771
- ];
1772
- }).s("AWSControlTowerApis", "GetLandingZoneOperation", {}).n("ControlTowerClient", "GetLandingZoneOperationCommand").f(void 0, void 0).ser(se_GetLandingZoneOperationCommand).de(de_GetLandingZoneOperationCommand).build() {
1773
- static {
1774
- __name(this, "GetLandingZoneOperationCommand");
1775
- }
327
+ const se_EnableBaselineCommand = async (input, context) => {
328
+ const b = core.requestBuilder(input, context);
329
+ const headers = {
330
+ "content-type": "application/json",
331
+ };
332
+ b.bp("/enable-baseline");
333
+ let body;
334
+ body = JSON.stringify(smithyClient.take(input, {
335
+ baselineIdentifier: [],
336
+ baselineVersion: [],
337
+ parameters: (_) => se_EnabledBaselineParameters(_),
338
+ tags: (_) => smithyClient._json(_),
339
+ targetIdentifier: [],
340
+ }));
341
+ b.m("POST").h(headers).b(body);
342
+ return b.build();
1776
343
  };
1777
-
1778
- // src/commands/ListBaselinesCommand.ts
1779
-
1780
-
1781
-
1782
- var ListBaselinesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1783
- return [
1784
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1785
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1786
- ];
1787
- }).s("AWSControlTowerApis", "ListBaselines", {}).n("ControlTowerClient", "ListBaselinesCommand").f(void 0, void 0).ser(se_ListBaselinesCommand).de(de_ListBaselinesCommand).build() {
1788
- static {
1789
- __name(this, "ListBaselinesCommand");
1790
- }
344
+ const se_EnableControlCommand = async (input, context) => {
345
+ const b = core.requestBuilder(input, context);
346
+ const headers = {
347
+ "content-type": "application/json",
348
+ };
349
+ b.bp("/enable-control");
350
+ let body;
351
+ body = JSON.stringify(smithyClient.take(input, {
352
+ controlIdentifier: [],
353
+ parameters: (_) => se_EnabledControlParameters(_),
354
+ tags: (_) => smithyClient._json(_),
355
+ targetIdentifier: [],
356
+ }));
357
+ b.m("POST").h(headers).b(body);
358
+ return b.build();
1791
359
  };
1792
-
1793
- // src/commands/ListControlOperationsCommand.ts
1794
-
1795
-
1796
-
1797
- var ListControlOperationsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1798
- return [
1799
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1800
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1801
- ];
1802
- }).s("AWSControlTowerApis", "ListControlOperations", {}).n("ControlTowerClient", "ListControlOperationsCommand").f(void 0, void 0).ser(se_ListControlOperationsCommand).de(de_ListControlOperationsCommand).build() {
1803
- static {
1804
- __name(this, "ListControlOperationsCommand");
1805
- }
360
+ const se_GetBaselineCommand = async (input, context) => {
361
+ const b = core.requestBuilder(input, context);
362
+ const headers = {
363
+ "content-type": "application/json",
364
+ };
365
+ b.bp("/get-baseline");
366
+ let body;
367
+ body = JSON.stringify(smithyClient.take(input, {
368
+ baselineIdentifier: [],
369
+ }));
370
+ b.m("POST").h(headers).b(body);
371
+ return b.build();
1806
372
  };
1807
-
1808
- // src/commands/ListEnabledBaselinesCommand.ts
1809
-
1810
-
1811
-
1812
- var ListEnabledBaselinesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1813
- return [
1814
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1815
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1816
- ];
1817
- }).s("AWSControlTowerApis", "ListEnabledBaselines", {}).n("ControlTowerClient", "ListEnabledBaselinesCommand").f(void 0, void 0).ser(se_ListEnabledBaselinesCommand).de(de_ListEnabledBaselinesCommand).build() {
1818
- static {
1819
- __name(this, "ListEnabledBaselinesCommand");
1820
- }
373
+ const se_GetBaselineOperationCommand = async (input, context) => {
374
+ const b = core.requestBuilder(input, context);
375
+ const headers = {
376
+ "content-type": "application/json",
377
+ };
378
+ b.bp("/get-baseline-operation");
379
+ let body;
380
+ body = JSON.stringify(smithyClient.take(input, {
381
+ operationIdentifier: [],
382
+ }));
383
+ b.m("POST").h(headers).b(body);
384
+ return b.build();
1821
385
  };
1822
-
1823
- // src/commands/ListEnabledControlsCommand.ts
1824
-
1825
-
1826
-
1827
- var ListEnabledControlsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1828
- return [
1829
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1830
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1831
- ];
1832
- }).s("AWSControlTowerApis", "ListEnabledControls", {}).n("ControlTowerClient", "ListEnabledControlsCommand").f(void 0, void 0).ser(se_ListEnabledControlsCommand).de(de_ListEnabledControlsCommand).build() {
1833
- static {
1834
- __name(this, "ListEnabledControlsCommand");
1835
- }
386
+ const se_GetControlOperationCommand = async (input, context) => {
387
+ const b = core.requestBuilder(input, context);
388
+ const headers = {
389
+ "content-type": "application/json",
390
+ };
391
+ b.bp("/get-control-operation");
392
+ let body;
393
+ body = JSON.stringify(smithyClient.take(input, {
394
+ operationIdentifier: [],
395
+ }));
396
+ b.m("POST").h(headers).b(body);
397
+ return b.build();
1836
398
  };
1837
-
1838
- // src/commands/ListLandingZoneOperationsCommand.ts
1839
-
1840
-
1841
-
1842
- var ListLandingZoneOperationsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1843
- return [
1844
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1845
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1846
- ];
1847
- }).s("AWSControlTowerApis", "ListLandingZoneOperations", {}).n("ControlTowerClient", "ListLandingZoneOperationsCommand").f(void 0, void 0).ser(se_ListLandingZoneOperationsCommand).de(de_ListLandingZoneOperationsCommand).build() {
1848
- static {
1849
- __name(this, "ListLandingZoneOperationsCommand");
1850
- }
399
+ const se_GetEnabledBaselineCommand = async (input, context) => {
400
+ const b = core.requestBuilder(input, context);
401
+ const headers = {
402
+ "content-type": "application/json",
403
+ };
404
+ b.bp("/get-enabled-baseline");
405
+ let body;
406
+ body = JSON.stringify(smithyClient.take(input, {
407
+ enabledBaselineIdentifier: [],
408
+ }));
409
+ b.m("POST").h(headers).b(body);
410
+ return b.build();
1851
411
  };
1852
-
1853
- // src/commands/ListLandingZonesCommand.ts
1854
-
1855
-
1856
-
1857
- var ListLandingZonesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1858
- return [
1859
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1860
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1861
- ];
1862
- }).s("AWSControlTowerApis", "ListLandingZones", {}).n("ControlTowerClient", "ListLandingZonesCommand").f(void 0, void 0).ser(se_ListLandingZonesCommand).de(de_ListLandingZonesCommand).build() {
1863
- static {
1864
- __name(this, "ListLandingZonesCommand");
1865
- }
412
+ const se_GetEnabledControlCommand = async (input, context) => {
413
+ const b = core.requestBuilder(input, context);
414
+ const headers = {
415
+ "content-type": "application/json",
416
+ };
417
+ b.bp("/get-enabled-control");
418
+ let body;
419
+ body = JSON.stringify(smithyClient.take(input, {
420
+ enabledControlIdentifier: [],
421
+ }));
422
+ b.m("POST").h(headers).b(body);
423
+ return b.build();
1866
424
  };
1867
-
1868
- // src/commands/ListTagsForResourceCommand.ts
1869
-
1870
-
1871
-
1872
- var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1873
- return [
1874
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1875
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1876
- ];
1877
- }).s("AWSControlTowerApis", "ListTagsForResource", {}).n("ControlTowerClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
1878
- static {
1879
- __name(this, "ListTagsForResourceCommand");
1880
- }
425
+ const se_GetLandingZoneCommand = async (input, context) => {
426
+ const b = core.requestBuilder(input, context);
427
+ const headers = {
428
+ "content-type": "application/json",
429
+ };
430
+ b.bp("/get-landingzone");
431
+ let body;
432
+ body = JSON.stringify(smithyClient.take(input, {
433
+ landingZoneIdentifier: [],
434
+ }));
435
+ b.m("POST").h(headers).b(body);
436
+ return b.build();
1881
437
  };
1882
-
1883
- // src/commands/ResetEnabledBaselineCommand.ts
1884
-
1885
-
1886
-
1887
- var ResetEnabledBaselineCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1888
- return [
1889
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1890
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1891
- ];
1892
- }).s("AWSControlTowerApis", "ResetEnabledBaseline", {}).n("ControlTowerClient", "ResetEnabledBaselineCommand").f(void 0, void 0).ser(se_ResetEnabledBaselineCommand).de(de_ResetEnabledBaselineCommand).build() {
1893
- static {
1894
- __name(this, "ResetEnabledBaselineCommand");
1895
- }
438
+ const se_GetLandingZoneOperationCommand = async (input, context) => {
439
+ const b = core.requestBuilder(input, context);
440
+ const headers = {
441
+ "content-type": "application/json",
442
+ };
443
+ b.bp("/get-landingzone-operation");
444
+ let body;
445
+ body = JSON.stringify(smithyClient.take(input, {
446
+ operationIdentifier: [],
447
+ }));
448
+ b.m("POST").h(headers).b(body);
449
+ return b.build();
1896
450
  };
1897
-
1898
- // src/commands/ResetEnabledControlCommand.ts
1899
-
1900
-
1901
-
1902
- var ResetEnabledControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1903
- return [
1904
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1905
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1906
- ];
1907
- }).s("AWSControlTowerApis", "ResetEnabledControl", {}).n("ControlTowerClient", "ResetEnabledControlCommand").f(void 0, void 0).ser(se_ResetEnabledControlCommand).de(de_ResetEnabledControlCommand).build() {
1908
- static {
1909
- __name(this, "ResetEnabledControlCommand");
1910
- }
451
+ const se_ListBaselinesCommand = async (input, context) => {
452
+ const b = core.requestBuilder(input, context);
453
+ const headers = {
454
+ "content-type": "application/json",
455
+ };
456
+ b.bp("/list-baselines");
457
+ let body;
458
+ body = JSON.stringify(smithyClient.take(input, {
459
+ maxResults: [],
460
+ nextToken: [],
461
+ }));
462
+ b.m("POST").h(headers).b(body);
463
+ return b.build();
1911
464
  };
1912
-
1913
- // src/commands/ResetLandingZoneCommand.ts
1914
-
1915
-
1916
-
1917
- var ResetLandingZoneCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1918
- return [
1919
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1920
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1921
- ];
1922
- }).s("AWSControlTowerApis", "ResetLandingZone", {}).n("ControlTowerClient", "ResetLandingZoneCommand").f(void 0, void 0).ser(se_ResetLandingZoneCommand).de(de_ResetLandingZoneCommand).build() {
1923
- static {
1924
- __name(this, "ResetLandingZoneCommand");
1925
- }
465
+ const se_ListControlOperationsCommand = async (input, context) => {
466
+ const b = core.requestBuilder(input, context);
467
+ const headers = {
468
+ "content-type": "application/json",
469
+ };
470
+ b.bp("/list-control-operations");
471
+ let body;
472
+ body = JSON.stringify(smithyClient.take(input, {
473
+ filter: (_) => smithyClient._json(_),
474
+ maxResults: [],
475
+ nextToken: [],
476
+ }));
477
+ b.m("POST").h(headers).b(body);
478
+ return b.build();
1926
479
  };
1927
-
1928
- // src/commands/TagResourceCommand.ts
1929
-
1930
-
1931
-
1932
- var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1933
- return [
1934
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1935
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1936
- ];
1937
- }).s("AWSControlTowerApis", "TagResource", {}).n("ControlTowerClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
1938
- static {
1939
- __name(this, "TagResourceCommand");
1940
- }
480
+ const se_ListEnabledBaselinesCommand = async (input, context) => {
481
+ const b = core.requestBuilder(input, context);
482
+ const headers = {
483
+ "content-type": "application/json",
484
+ };
485
+ b.bp("/list-enabled-baselines");
486
+ let body;
487
+ body = JSON.stringify(smithyClient.take(input, {
488
+ filter: (_) => smithyClient._json(_),
489
+ includeChildren: [],
490
+ maxResults: [],
491
+ nextToken: [],
492
+ }));
493
+ b.m("POST").h(headers).b(body);
494
+ return b.build();
1941
495
  };
1942
-
1943
- // src/commands/UntagResourceCommand.ts
1944
-
1945
-
1946
-
1947
- var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1948
- return [
1949
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1950
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1951
- ];
1952
- }).s("AWSControlTowerApis", "UntagResource", {}).n("ControlTowerClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
1953
- static {
1954
- __name(this, "UntagResourceCommand");
1955
- }
496
+ const se_ListEnabledControlsCommand = async (input, context) => {
497
+ const b = core.requestBuilder(input, context);
498
+ const headers = {
499
+ "content-type": "application/json",
500
+ };
501
+ b.bp("/list-enabled-controls");
502
+ let body;
503
+ body = JSON.stringify(smithyClient.take(input, {
504
+ filter: (_) => smithyClient._json(_),
505
+ maxResults: [],
506
+ nextToken: [],
507
+ targetIdentifier: [],
508
+ }));
509
+ b.m("POST").h(headers).b(body);
510
+ return b.build();
1956
511
  };
1957
-
1958
- // src/commands/UpdateEnabledBaselineCommand.ts
1959
-
1960
-
1961
-
1962
- var UpdateEnabledBaselineCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1963
- return [
1964
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1965
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1966
- ];
1967
- }).s("AWSControlTowerApis", "UpdateEnabledBaseline", {}).n("ControlTowerClient", "UpdateEnabledBaselineCommand").f(void 0, void 0).ser(se_UpdateEnabledBaselineCommand).de(de_UpdateEnabledBaselineCommand).build() {
1968
- static {
1969
- __name(this, "UpdateEnabledBaselineCommand");
1970
- }
512
+ const se_ListLandingZoneOperationsCommand = async (input, context) => {
513
+ const b = core.requestBuilder(input, context);
514
+ const headers = {
515
+ "content-type": "application/json",
516
+ };
517
+ b.bp("/list-landingzone-operations");
518
+ let body;
519
+ body = JSON.stringify(smithyClient.take(input, {
520
+ filter: (_) => smithyClient._json(_),
521
+ maxResults: [],
522
+ nextToken: [],
523
+ }));
524
+ b.m("POST").h(headers).b(body);
525
+ return b.build();
1971
526
  };
1972
-
1973
- // src/commands/UpdateEnabledControlCommand.ts
1974
-
1975
-
1976
-
1977
- var UpdateEnabledControlCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1978
- return [
1979
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1980
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1981
- ];
1982
- }).s("AWSControlTowerApis", "UpdateEnabledControl", {}).n("ControlTowerClient", "UpdateEnabledControlCommand").f(void 0, void 0).ser(se_UpdateEnabledControlCommand).de(de_UpdateEnabledControlCommand).build() {
1983
- static {
1984
- __name(this, "UpdateEnabledControlCommand");
1985
- }
527
+ const se_ListLandingZonesCommand = async (input, context) => {
528
+ const b = core.requestBuilder(input, context);
529
+ const headers = {
530
+ "content-type": "application/json",
531
+ };
532
+ b.bp("/list-landingzones");
533
+ let body;
534
+ body = JSON.stringify(smithyClient.take(input, {
535
+ maxResults: [],
536
+ nextToken: [],
537
+ }));
538
+ b.m("POST").h(headers).b(body);
539
+ return b.build();
1986
540
  };
1987
-
1988
- // src/commands/UpdateLandingZoneCommand.ts
1989
-
1990
-
1991
-
1992
- var UpdateLandingZoneCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1993
- return [
1994
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1995
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1996
- ];
1997
- }).s("AWSControlTowerApis", "UpdateLandingZone", {}).n("ControlTowerClient", "UpdateLandingZoneCommand").f(void 0, void 0).ser(se_UpdateLandingZoneCommand).de(de_UpdateLandingZoneCommand).build() {
1998
- static {
1999
- __name(this, "UpdateLandingZoneCommand");
2000
- }
541
+ const se_ListTagsForResourceCommand = async (input, context) => {
542
+ const b = core.requestBuilder(input, context);
543
+ const headers = {};
544
+ b.bp("/tags/{resourceArn}");
545
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
546
+ let body;
547
+ b.m("GET").h(headers).b(body);
548
+ return b.build();
2001
549
  };
550
+ const se_ResetEnabledBaselineCommand = async (input, context) => {
551
+ const b = core.requestBuilder(input, context);
552
+ const headers = {
553
+ "content-type": "application/json",
554
+ };
555
+ b.bp("/reset-enabled-baseline");
556
+ let body;
557
+ body = JSON.stringify(smithyClient.take(input, {
558
+ enabledBaselineIdentifier: [],
559
+ }));
560
+ b.m("POST").h(headers).b(body);
561
+ return b.build();
562
+ };
563
+ const se_ResetEnabledControlCommand = async (input, context) => {
564
+ const b = core.requestBuilder(input, context);
565
+ const headers = {
566
+ "content-type": "application/json",
567
+ };
568
+ b.bp("/reset-enabled-control");
569
+ let body;
570
+ body = JSON.stringify(smithyClient.take(input, {
571
+ enabledControlIdentifier: [],
572
+ }));
573
+ b.m("POST").h(headers).b(body);
574
+ return b.build();
575
+ };
576
+ const se_ResetLandingZoneCommand = async (input, context) => {
577
+ const b = core.requestBuilder(input, context);
578
+ const headers = {
579
+ "content-type": "application/json",
580
+ };
581
+ b.bp("/reset-landingzone");
582
+ let body;
583
+ body = JSON.stringify(smithyClient.take(input, {
584
+ landingZoneIdentifier: [],
585
+ }));
586
+ b.m("POST").h(headers).b(body);
587
+ return b.build();
588
+ };
589
+ const se_TagResourceCommand = async (input, context) => {
590
+ const b = core.requestBuilder(input, context);
591
+ const headers = {
592
+ "content-type": "application/json",
593
+ };
594
+ b.bp("/tags/{resourceArn}");
595
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
596
+ let body;
597
+ body = JSON.stringify(smithyClient.take(input, {
598
+ tags: (_) => smithyClient._json(_),
599
+ }));
600
+ b.m("POST").h(headers).b(body);
601
+ return b.build();
602
+ };
603
+ const se_UntagResourceCommand = async (input, context) => {
604
+ const b = core.requestBuilder(input, context);
605
+ const headers = {};
606
+ b.bp("/tags/{resourceArn}");
607
+ b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
608
+ const query = smithyClient.map({
609
+ [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
610
+ });
611
+ let body;
612
+ b.m("DELETE").h(headers).q(query).b(body);
613
+ return b.build();
614
+ };
615
+ const se_UpdateEnabledBaselineCommand = async (input, context) => {
616
+ const b = core.requestBuilder(input, context);
617
+ const headers = {
618
+ "content-type": "application/json",
619
+ };
620
+ b.bp("/update-enabled-baseline");
621
+ let body;
622
+ body = JSON.stringify(smithyClient.take(input, {
623
+ baselineVersion: [],
624
+ enabledBaselineIdentifier: [],
625
+ parameters: (_) => se_EnabledBaselineParameters(_),
626
+ }));
627
+ b.m("POST").h(headers).b(body);
628
+ return b.build();
629
+ };
630
+ const se_UpdateEnabledControlCommand = async (input, context) => {
631
+ const b = core.requestBuilder(input, context);
632
+ const headers = {
633
+ "content-type": "application/json",
634
+ };
635
+ b.bp("/update-enabled-control");
636
+ let body;
637
+ body = JSON.stringify(smithyClient.take(input, {
638
+ enabledControlIdentifier: [],
639
+ parameters: (_) => se_EnabledControlParameters(_),
640
+ }));
641
+ b.m("POST").h(headers).b(body);
642
+ return b.build();
643
+ };
644
+ const se_UpdateLandingZoneCommand = async (input, context) => {
645
+ const b = core.requestBuilder(input, context);
646
+ const headers = {
647
+ "content-type": "application/json",
648
+ };
649
+ b.bp("/update-landingzone");
650
+ let body;
651
+ body = JSON.stringify(smithyClient.take(input, {
652
+ landingZoneIdentifier: [],
653
+ manifest: (_) => se_Manifest(_),
654
+ version: [],
655
+ }));
656
+ b.m("POST").h(headers).b(body);
657
+ return b.build();
658
+ };
659
+ const de_CreateLandingZoneCommand = async (output, context) => {
660
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
661
+ return de_CommandError(output, context);
662
+ }
663
+ const contents = smithyClient.map({
664
+ $metadata: deserializeMetadata(output),
665
+ });
666
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
667
+ const doc = smithyClient.take(data, {
668
+ arn: smithyClient.expectString,
669
+ operationIdentifier: smithyClient.expectString,
670
+ });
671
+ Object.assign(contents, doc);
672
+ return contents;
673
+ };
674
+ const de_DeleteLandingZoneCommand = async (output, context) => {
675
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
676
+ return de_CommandError(output, context);
677
+ }
678
+ const contents = smithyClient.map({
679
+ $metadata: deserializeMetadata(output),
680
+ });
681
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
682
+ const doc = smithyClient.take(data, {
683
+ operationIdentifier: smithyClient.expectString,
684
+ });
685
+ Object.assign(contents, doc);
686
+ return contents;
687
+ };
688
+ const de_DisableBaselineCommand = async (output, context) => {
689
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
690
+ return de_CommandError(output, context);
691
+ }
692
+ const contents = smithyClient.map({
693
+ $metadata: deserializeMetadata(output),
694
+ });
695
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
696
+ const doc = smithyClient.take(data, {
697
+ operationIdentifier: smithyClient.expectString,
698
+ });
699
+ Object.assign(contents, doc);
700
+ return contents;
701
+ };
702
+ const de_DisableControlCommand = async (output, context) => {
703
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
704
+ return de_CommandError(output, context);
705
+ }
706
+ const contents = smithyClient.map({
707
+ $metadata: deserializeMetadata(output),
708
+ });
709
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
710
+ const doc = smithyClient.take(data, {
711
+ operationIdentifier: smithyClient.expectString,
712
+ });
713
+ Object.assign(contents, doc);
714
+ return contents;
715
+ };
716
+ const de_EnableBaselineCommand = async (output, context) => {
717
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
718
+ return de_CommandError(output, context);
719
+ }
720
+ const contents = smithyClient.map({
721
+ $metadata: deserializeMetadata(output),
722
+ });
723
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
724
+ const doc = smithyClient.take(data, {
725
+ arn: smithyClient.expectString,
726
+ operationIdentifier: smithyClient.expectString,
727
+ });
728
+ Object.assign(contents, doc);
729
+ return contents;
730
+ };
731
+ const de_EnableControlCommand = async (output, context) => {
732
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
733
+ return de_CommandError(output, context);
734
+ }
735
+ const contents = smithyClient.map({
736
+ $metadata: deserializeMetadata(output),
737
+ });
738
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
739
+ const doc = smithyClient.take(data, {
740
+ arn: smithyClient.expectString,
741
+ operationIdentifier: smithyClient.expectString,
742
+ });
743
+ Object.assign(contents, doc);
744
+ return contents;
745
+ };
746
+ const de_GetBaselineCommand = async (output, context) => {
747
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
748
+ return de_CommandError(output, context);
749
+ }
750
+ const contents = smithyClient.map({
751
+ $metadata: deserializeMetadata(output),
752
+ });
753
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
754
+ const doc = smithyClient.take(data, {
755
+ arn: smithyClient.expectString,
756
+ description: smithyClient.expectString,
757
+ name: smithyClient.expectString,
758
+ });
759
+ Object.assign(contents, doc);
760
+ return contents;
761
+ };
762
+ const de_GetBaselineOperationCommand = async (output, context) => {
763
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
764
+ return de_CommandError(output, context);
765
+ }
766
+ const contents = smithyClient.map({
767
+ $metadata: deserializeMetadata(output),
768
+ });
769
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
770
+ const doc = smithyClient.take(data, {
771
+ baselineOperation: (_) => de_BaselineOperation(_),
772
+ });
773
+ Object.assign(contents, doc);
774
+ return contents;
775
+ };
776
+ const de_GetControlOperationCommand = async (output, context) => {
777
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
778
+ return de_CommandError(output, context);
779
+ }
780
+ const contents = smithyClient.map({
781
+ $metadata: deserializeMetadata(output),
782
+ });
783
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
784
+ const doc = smithyClient.take(data, {
785
+ controlOperation: (_) => de_ControlOperation(_),
786
+ });
787
+ Object.assign(contents, doc);
788
+ return contents;
789
+ };
790
+ const de_GetEnabledBaselineCommand = async (output, context) => {
791
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
792
+ return de_CommandError(output, context);
793
+ }
794
+ const contents = smithyClient.map({
795
+ $metadata: deserializeMetadata(output),
796
+ });
797
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
798
+ const doc = smithyClient.take(data, {
799
+ enabledBaselineDetails: (_) => de_EnabledBaselineDetails(_),
800
+ });
801
+ Object.assign(contents, doc);
802
+ return contents;
803
+ };
804
+ const de_GetEnabledControlCommand = async (output, context) => {
805
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
806
+ return de_CommandError(output, context);
807
+ }
808
+ const contents = smithyClient.map({
809
+ $metadata: deserializeMetadata(output),
810
+ });
811
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
812
+ const doc = smithyClient.take(data, {
813
+ enabledControlDetails: (_) => de_EnabledControlDetails(_),
814
+ });
815
+ Object.assign(contents, doc);
816
+ return contents;
817
+ };
818
+ const de_GetLandingZoneCommand = async (output, context) => {
819
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
820
+ return de_CommandError(output, context);
821
+ }
822
+ const contents = smithyClient.map({
823
+ $metadata: deserializeMetadata(output),
824
+ });
825
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
826
+ const doc = smithyClient.take(data, {
827
+ landingZone: (_) => de_LandingZoneDetail(_),
828
+ });
829
+ Object.assign(contents, doc);
830
+ return contents;
831
+ };
832
+ const de_GetLandingZoneOperationCommand = async (output, context) => {
833
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
834
+ return de_CommandError(output, context);
835
+ }
836
+ const contents = smithyClient.map({
837
+ $metadata: deserializeMetadata(output),
838
+ });
839
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
840
+ const doc = smithyClient.take(data, {
841
+ operationDetails: (_) => de_LandingZoneOperationDetail(_),
842
+ });
843
+ Object.assign(contents, doc);
844
+ return contents;
845
+ };
846
+ const de_ListBaselinesCommand = async (output, context) => {
847
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
848
+ return de_CommandError(output, context);
849
+ }
850
+ const contents = smithyClient.map({
851
+ $metadata: deserializeMetadata(output),
852
+ });
853
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
854
+ const doc = smithyClient.take(data, {
855
+ baselines: smithyClient._json,
856
+ nextToken: smithyClient.expectString,
857
+ });
858
+ Object.assign(contents, doc);
859
+ return contents;
860
+ };
861
+ const de_ListControlOperationsCommand = async (output, context) => {
862
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
863
+ return de_CommandError(output, context);
864
+ }
865
+ const contents = smithyClient.map({
866
+ $metadata: deserializeMetadata(output),
867
+ });
868
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
869
+ const doc = smithyClient.take(data, {
870
+ controlOperations: (_) => de_ControlOperations(_),
871
+ nextToken: smithyClient.expectString,
872
+ });
873
+ Object.assign(contents, doc);
874
+ return contents;
875
+ };
876
+ const de_ListEnabledBaselinesCommand = async (output, context) => {
877
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
878
+ return de_CommandError(output, context);
879
+ }
880
+ const contents = smithyClient.map({
881
+ $metadata: deserializeMetadata(output),
882
+ });
883
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
884
+ const doc = smithyClient.take(data, {
885
+ enabledBaselines: smithyClient._json,
886
+ nextToken: smithyClient.expectString,
887
+ });
888
+ Object.assign(contents, doc);
889
+ return contents;
890
+ };
891
+ const de_ListEnabledControlsCommand = async (output, context) => {
892
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
893
+ return de_CommandError(output, context);
894
+ }
895
+ const contents = smithyClient.map({
896
+ $metadata: deserializeMetadata(output),
897
+ });
898
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
899
+ const doc = smithyClient.take(data, {
900
+ enabledControls: smithyClient._json,
901
+ nextToken: smithyClient.expectString,
902
+ });
903
+ Object.assign(contents, doc);
904
+ return contents;
905
+ };
906
+ const de_ListLandingZoneOperationsCommand = async (output, context) => {
907
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
908
+ return de_CommandError(output, context);
909
+ }
910
+ const contents = smithyClient.map({
911
+ $metadata: deserializeMetadata(output),
912
+ });
913
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
914
+ const doc = smithyClient.take(data, {
915
+ landingZoneOperations: smithyClient._json,
916
+ nextToken: smithyClient.expectString,
917
+ });
918
+ Object.assign(contents, doc);
919
+ return contents;
920
+ };
921
+ const de_ListLandingZonesCommand = async (output, context) => {
922
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
923
+ return de_CommandError(output, context);
924
+ }
925
+ const contents = smithyClient.map({
926
+ $metadata: deserializeMetadata(output),
927
+ });
928
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
929
+ const doc = smithyClient.take(data, {
930
+ landingZones: smithyClient._json,
931
+ nextToken: smithyClient.expectString,
932
+ });
933
+ Object.assign(contents, doc);
934
+ return contents;
935
+ };
936
+ const de_ListTagsForResourceCommand = async (output, context) => {
937
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
938
+ return de_CommandError(output, context);
939
+ }
940
+ const contents = smithyClient.map({
941
+ $metadata: deserializeMetadata(output),
942
+ });
943
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
944
+ const doc = smithyClient.take(data, {
945
+ tags: smithyClient._json,
946
+ });
947
+ Object.assign(contents, doc);
948
+ return contents;
949
+ };
950
+ const de_ResetEnabledBaselineCommand = async (output, context) => {
951
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
952
+ return de_CommandError(output, context);
953
+ }
954
+ const contents = smithyClient.map({
955
+ $metadata: deserializeMetadata(output),
956
+ });
957
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
958
+ const doc = smithyClient.take(data, {
959
+ operationIdentifier: smithyClient.expectString,
960
+ });
961
+ Object.assign(contents, doc);
962
+ return contents;
963
+ };
964
+ const de_ResetEnabledControlCommand = async (output, context) => {
965
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
966
+ return de_CommandError(output, context);
967
+ }
968
+ const contents = smithyClient.map({
969
+ $metadata: deserializeMetadata(output),
970
+ });
971
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
972
+ const doc = smithyClient.take(data, {
973
+ operationIdentifier: smithyClient.expectString,
974
+ });
975
+ Object.assign(contents, doc);
976
+ return contents;
977
+ };
978
+ const de_ResetLandingZoneCommand = async (output, context) => {
979
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
980
+ return de_CommandError(output, context);
981
+ }
982
+ const contents = smithyClient.map({
983
+ $metadata: deserializeMetadata(output),
984
+ });
985
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
986
+ const doc = smithyClient.take(data, {
987
+ operationIdentifier: smithyClient.expectString,
988
+ });
989
+ Object.assign(contents, doc);
990
+ return contents;
991
+ };
992
+ const de_TagResourceCommand = async (output, context) => {
993
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
994
+ return de_CommandError(output, context);
995
+ }
996
+ const contents = smithyClient.map({
997
+ $metadata: deserializeMetadata(output),
998
+ });
999
+ await smithyClient.collectBody(output.body, context);
1000
+ return contents;
1001
+ };
1002
+ const de_UntagResourceCommand = async (output, context) => {
1003
+ if (output.statusCode !== 204 && output.statusCode >= 300) {
1004
+ return de_CommandError(output, context);
1005
+ }
1006
+ const contents = smithyClient.map({
1007
+ $metadata: deserializeMetadata(output),
1008
+ });
1009
+ await smithyClient.collectBody(output.body, context);
1010
+ return contents;
1011
+ };
1012
+ const de_UpdateEnabledBaselineCommand = async (output, context) => {
1013
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1014
+ return de_CommandError(output, context);
1015
+ }
1016
+ const contents = smithyClient.map({
1017
+ $metadata: deserializeMetadata(output),
1018
+ });
1019
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
1020
+ const doc = smithyClient.take(data, {
1021
+ operationIdentifier: smithyClient.expectString,
1022
+ });
1023
+ Object.assign(contents, doc);
1024
+ return contents;
1025
+ };
1026
+ const de_UpdateEnabledControlCommand = async (output, context) => {
1027
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1028
+ return de_CommandError(output, context);
1029
+ }
1030
+ const contents = smithyClient.map({
1031
+ $metadata: deserializeMetadata(output),
1032
+ });
1033
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
1034
+ const doc = smithyClient.take(data, {
1035
+ operationIdentifier: smithyClient.expectString,
1036
+ });
1037
+ Object.assign(contents, doc);
1038
+ return contents;
1039
+ };
1040
+ const de_UpdateLandingZoneCommand = async (output, context) => {
1041
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1042
+ return de_CommandError(output, context);
1043
+ }
1044
+ const contents = smithyClient.map({
1045
+ $metadata: deserializeMetadata(output),
1046
+ });
1047
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
1048
+ const doc = smithyClient.take(data, {
1049
+ operationIdentifier: smithyClient.expectString,
1050
+ });
1051
+ Object.assign(contents, doc);
1052
+ return contents;
1053
+ };
1054
+ const de_CommandError = async (output, context) => {
1055
+ const parsedOutput = {
1056
+ ...output,
1057
+ body: await core$1.parseJsonErrorBody(output.body, context),
1058
+ };
1059
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
1060
+ switch (errorCode) {
1061
+ case "AccessDeniedException":
1062
+ case "com.amazonaws.controltower#AccessDeniedException":
1063
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
1064
+ case "ConflictException":
1065
+ case "com.amazonaws.controltower#ConflictException":
1066
+ throw await de_ConflictExceptionRes(parsedOutput);
1067
+ case "InternalServerException":
1068
+ case "com.amazonaws.controltower#InternalServerException":
1069
+ throw await de_InternalServerExceptionRes(parsedOutput);
1070
+ case "ThrottlingException":
1071
+ case "com.amazonaws.controltower#ThrottlingException":
1072
+ throw await de_ThrottlingExceptionRes(parsedOutput);
1073
+ case "ValidationException":
1074
+ case "com.amazonaws.controltower#ValidationException":
1075
+ throw await de_ValidationExceptionRes(parsedOutput);
1076
+ case "ResourceNotFoundException":
1077
+ case "com.amazonaws.controltower#ResourceNotFoundException":
1078
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
1079
+ case "ServiceQuotaExceededException":
1080
+ case "com.amazonaws.controltower#ServiceQuotaExceededException":
1081
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
1082
+ default:
1083
+ const parsedBody = parsedOutput.body;
1084
+ return throwDefaultError({
1085
+ output,
1086
+ parsedBody,
1087
+ errorCode,
1088
+ });
1089
+ }
1090
+ };
1091
+ const throwDefaultError = smithyClient.withBaseException(ControlTowerServiceException);
1092
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
1093
+ const contents = smithyClient.map({});
1094
+ const data = parsedOutput.body;
1095
+ const doc = smithyClient.take(data, {
1096
+ message: smithyClient.expectString,
1097
+ });
1098
+ Object.assign(contents, doc);
1099
+ const exception = new AccessDeniedException({
1100
+ $metadata: deserializeMetadata(parsedOutput),
1101
+ ...contents,
1102
+ });
1103
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1104
+ };
1105
+ const de_ConflictExceptionRes = async (parsedOutput, context) => {
1106
+ const contents = smithyClient.map({});
1107
+ const data = parsedOutput.body;
1108
+ const doc = smithyClient.take(data, {
1109
+ message: smithyClient.expectString,
1110
+ });
1111
+ Object.assign(contents, doc);
1112
+ const exception = new ConflictException({
1113
+ $metadata: deserializeMetadata(parsedOutput),
1114
+ ...contents,
1115
+ });
1116
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1117
+ };
1118
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
1119
+ const contents = smithyClient.map({});
1120
+ const data = parsedOutput.body;
1121
+ const doc = smithyClient.take(data, {
1122
+ message: smithyClient.expectString,
1123
+ });
1124
+ Object.assign(contents, doc);
1125
+ const exception = new InternalServerException({
1126
+ $metadata: deserializeMetadata(parsedOutput),
1127
+ ...contents,
1128
+ });
1129
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1130
+ };
1131
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
1132
+ const contents = smithyClient.map({});
1133
+ const data = parsedOutput.body;
1134
+ const doc = smithyClient.take(data, {
1135
+ message: smithyClient.expectString,
1136
+ });
1137
+ Object.assign(contents, doc);
1138
+ const exception = new ResourceNotFoundException({
1139
+ $metadata: deserializeMetadata(parsedOutput),
1140
+ ...contents,
1141
+ });
1142
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1143
+ };
1144
+ const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
1145
+ const contents = smithyClient.map({});
1146
+ const data = parsedOutput.body;
1147
+ const doc = smithyClient.take(data, {
1148
+ message: smithyClient.expectString,
1149
+ });
1150
+ Object.assign(contents, doc);
1151
+ const exception = new ServiceQuotaExceededException({
1152
+ $metadata: deserializeMetadata(parsedOutput),
1153
+ ...contents,
1154
+ });
1155
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1156
+ };
1157
+ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
1158
+ const contents = smithyClient.map({
1159
+ [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
1160
+ });
1161
+ const data = parsedOutput.body;
1162
+ const doc = smithyClient.take(data, {
1163
+ message: smithyClient.expectString,
1164
+ quotaCode: smithyClient.expectString,
1165
+ serviceCode: smithyClient.expectString,
1166
+ });
1167
+ Object.assign(contents, doc);
1168
+ const exception = new ThrottlingException({
1169
+ $metadata: deserializeMetadata(parsedOutput),
1170
+ ...contents,
1171
+ });
1172
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1173
+ };
1174
+ const de_ValidationExceptionRes = async (parsedOutput, context) => {
1175
+ const contents = smithyClient.map({});
1176
+ const data = parsedOutput.body;
1177
+ const doc = smithyClient.take(data, {
1178
+ message: smithyClient.expectString,
1179
+ });
1180
+ Object.assign(contents, doc);
1181
+ const exception = new ValidationException({
1182
+ $metadata: deserializeMetadata(parsedOutput),
1183
+ ...contents,
1184
+ });
1185
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1186
+ };
1187
+ const se_EnabledBaselineParameter = (input, context) => {
1188
+ return smithyClient.take(input, {
1189
+ key: [],
1190
+ value: (_) => se_EnabledBaselineParameterDocument(_),
1191
+ });
1192
+ };
1193
+ const se_EnabledBaselineParameterDocument = (input, context) => {
1194
+ return input;
1195
+ };
1196
+ const se_EnabledBaselineParameters = (input, context) => {
1197
+ return input
1198
+ .filter((e) => e != null)
1199
+ .map((entry) => {
1200
+ return se_EnabledBaselineParameter(entry);
1201
+ });
1202
+ };
1203
+ const se_EnabledControlParameter = (input, context) => {
1204
+ return smithyClient.take(input, {
1205
+ key: [],
1206
+ value: (_) => se_Document(_),
1207
+ });
1208
+ };
1209
+ const se_EnabledControlParameters = (input, context) => {
1210
+ return input
1211
+ .filter((e) => e != null)
1212
+ .map((entry) => {
1213
+ return se_EnabledControlParameter(entry);
1214
+ });
1215
+ };
1216
+ const se_Manifest = (input, context) => {
1217
+ return input;
1218
+ };
1219
+ const se_Document = (input, context) => {
1220
+ return input;
1221
+ };
1222
+ const de_BaselineOperation = (output, context) => {
1223
+ return smithyClient.take(output, {
1224
+ endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1225
+ operationIdentifier: smithyClient.expectString,
1226
+ operationType: smithyClient.expectString,
1227
+ startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1228
+ status: smithyClient.expectString,
1229
+ statusMessage: smithyClient.expectString,
1230
+ });
1231
+ };
1232
+ const de_ControlOperation = (output, context) => {
1233
+ return smithyClient.take(output, {
1234
+ controlIdentifier: smithyClient.expectString,
1235
+ enabledControlIdentifier: smithyClient.expectString,
1236
+ endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1237
+ operationIdentifier: smithyClient.expectString,
1238
+ operationType: smithyClient.expectString,
1239
+ startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1240
+ status: smithyClient.expectString,
1241
+ statusMessage: smithyClient.expectString,
1242
+ targetIdentifier: smithyClient.expectString,
1243
+ });
1244
+ };
1245
+ const de_ControlOperations = (output, context) => {
1246
+ const retVal = (output || [])
1247
+ .filter((e) => e != null)
1248
+ .map((entry) => {
1249
+ return de_ControlOperationSummary(entry);
1250
+ });
1251
+ return retVal;
1252
+ };
1253
+ const de_ControlOperationSummary = (output, context) => {
1254
+ return smithyClient.take(output, {
1255
+ controlIdentifier: smithyClient.expectString,
1256
+ enabledControlIdentifier: smithyClient.expectString,
1257
+ endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1258
+ operationIdentifier: smithyClient.expectString,
1259
+ operationType: smithyClient.expectString,
1260
+ startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1261
+ status: smithyClient.expectString,
1262
+ statusMessage: smithyClient.expectString,
1263
+ targetIdentifier: smithyClient.expectString,
1264
+ });
1265
+ };
1266
+ const de_EnabledBaselineDetails = (output, context) => {
1267
+ return smithyClient.take(output, {
1268
+ arn: smithyClient.expectString,
1269
+ baselineIdentifier: smithyClient.expectString,
1270
+ baselineVersion: smithyClient.expectString,
1271
+ driftStatusSummary: smithyClient._json,
1272
+ parameters: (_) => de_EnabledBaselineParameterSummaries(_),
1273
+ parentIdentifier: smithyClient.expectString,
1274
+ statusSummary: smithyClient._json,
1275
+ targetIdentifier: smithyClient.expectString,
1276
+ });
1277
+ };
1278
+ const de_EnabledBaselineParameterDocument = (output, context) => {
1279
+ return output;
1280
+ };
1281
+ const de_EnabledBaselineParameterSummaries = (output, context) => {
1282
+ const retVal = (output || [])
1283
+ .filter((e) => e != null)
1284
+ .map((entry) => {
1285
+ return de_EnabledBaselineParameterSummary(entry);
1286
+ });
1287
+ return retVal;
1288
+ };
1289
+ const de_EnabledBaselineParameterSummary = (output, context) => {
1290
+ return smithyClient.take(output, {
1291
+ key: smithyClient.expectString,
1292
+ value: (_) => de_EnabledBaselineParameterDocument(_),
1293
+ });
1294
+ };
1295
+ const de_EnabledControlDetails = (output, context) => {
1296
+ return smithyClient.take(output, {
1297
+ arn: smithyClient.expectString,
1298
+ controlIdentifier: smithyClient.expectString,
1299
+ driftStatusSummary: smithyClient._json,
1300
+ parameters: (_) => de_EnabledControlParameterSummaries(_),
1301
+ statusSummary: smithyClient._json,
1302
+ targetIdentifier: smithyClient.expectString,
1303
+ targetRegions: smithyClient._json,
1304
+ });
1305
+ };
1306
+ const de_EnabledControlParameterSummaries = (output, context) => {
1307
+ const retVal = (output || [])
1308
+ .filter((e) => e != null)
1309
+ .map((entry) => {
1310
+ return de_EnabledControlParameterSummary(entry);
1311
+ });
1312
+ return retVal;
1313
+ };
1314
+ const de_EnabledControlParameterSummary = (output, context) => {
1315
+ return smithyClient.take(output, {
1316
+ key: smithyClient.expectString,
1317
+ value: (_) => de_Document(_),
1318
+ });
1319
+ };
1320
+ const de_LandingZoneDetail = (output, context) => {
1321
+ return smithyClient.take(output, {
1322
+ arn: smithyClient.expectString,
1323
+ driftStatus: smithyClient._json,
1324
+ latestAvailableVersion: smithyClient.expectString,
1325
+ manifest: (_) => de_Manifest(_),
1326
+ status: smithyClient.expectString,
1327
+ version: smithyClient.expectString,
1328
+ });
1329
+ };
1330
+ const de_LandingZoneOperationDetail = (output, context) => {
1331
+ return smithyClient.take(output, {
1332
+ endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1333
+ operationIdentifier: smithyClient.expectString,
1334
+ operationType: smithyClient.expectString,
1335
+ startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
1336
+ status: smithyClient.expectString,
1337
+ statusMessage: smithyClient.expectString,
1338
+ });
1339
+ };
1340
+ const de_Manifest = (output, context) => {
1341
+ return output;
1342
+ };
1343
+ const de_Document = (output, context) => {
1344
+ return output;
1345
+ };
1346
+ const deserializeMetadata = (output) => ({
1347
+ httpStatusCode: output.statusCode,
1348
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1349
+ extendedRequestId: output.headers["x-amz-id-2"],
1350
+ cfId: output.headers["x-amz-cf-id"],
1351
+ });
1352
+ const _rAS = "retryAfterSeconds";
1353
+ const _ra = "retry-after";
1354
+ const _tK = "tagKeys";
1355
+
1356
+ class CreateLandingZoneCommand extends smithyClient.Command
1357
+ .classBuilder()
1358
+ .ep(commonParams)
1359
+ .m(function (Command, cs, config, o) {
1360
+ return [
1361
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1362
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1363
+ ];
1364
+ })
1365
+ .s("AWSControlTowerApis", "CreateLandingZone", {})
1366
+ .n("ControlTowerClient", "CreateLandingZoneCommand")
1367
+ .f(void 0, void 0)
1368
+ .ser(se_CreateLandingZoneCommand)
1369
+ .de(de_CreateLandingZoneCommand)
1370
+ .build() {
1371
+ }
1372
+
1373
+ class DeleteLandingZoneCommand extends smithyClient.Command
1374
+ .classBuilder()
1375
+ .ep(commonParams)
1376
+ .m(function (Command, cs, config, o) {
1377
+ return [
1378
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1379
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1380
+ ];
1381
+ })
1382
+ .s("AWSControlTowerApis", "DeleteLandingZone", {})
1383
+ .n("ControlTowerClient", "DeleteLandingZoneCommand")
1384
+ .f(void 0, void 0)
1385
+ .ser(se_DeleteLandingZoneCommand)
1386
+ .de(de_DeleteLandingZoneCommand)
1387
+ .build() {
1388
+ }
1389
+
1390
+ class DisableBaselineCommand extends smithyClient.Command
1391
+ .classBuilder()
1392
+ .ep(commonParams)
1393
+ .m(function (Command, cs, config, o) {
1394
+ return [
1395
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1396
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1397
+ ];
1398
+ })
1399
+ .s("AWSControlTowerApis", "DisableBaseline", {})
1400
+ .n("ControlTowerClient", "DisableBaselineCommand")
1401
+ .f(void 0, void 0)
1402
+ .ser(se_DisableBaselineCommand)
1403
+ .de(de_DisableBaselineCommand)
1404
+ .build() {
1405
+ }
1406
+
1407
+ class DisableControlCommand extends smithyClient.Command
1408
+ .classBuilder()
1409
+ .ep(commonParams)
1410
+ .m(function (Command, cs, config, o) {
1411
+ return [
1412
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1413
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1414
+ ];
1415
+ })
1416
+ .s("AWSControlTowerApis", "DisableControl", {})
1417
+ .n("ControlTowerClient", "DisableControlCommand")
1418
+ .f(void 0, void 0)
1419
+ .ser(se_DisableControlCommand)
1420
+ .de(de_DisableControlCommand)
1421
+ .build() {
1422
+ }
1423
+
1424
+ class EnableBaselineCommand extends smithyClient.Command
1425
+ .classBuilder()
1426
+ .ep(commonParams)
1427
+ .m(function (Command, cs, config, o) {
1428
+ return [
1429
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1430
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1431
+ ];
1432
+ })
1433
+ .s("AWSControlTowerApis", "EnableBaseline", {})
1434
+ .n("ControlTowerClient", "EnableBaselineCommand")
1435
+ .f(void 0, void 0)
1436
+ .ser(se_EnableBaselineCommand)
1437
+ .de(de_EnableBaselineCommand)
1438
+ .build() {
1439
+ }
1440
+
1441
+ class EnableControlCommand extends smithyClient.Command
1442
+ .classBuilder()
1443
+ .ep(commonParams)
1444
+ .m(function (Command, cs, config, o) {
1445
+ return [
1446
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1447
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1448
+ ];
1449
+ })
1450
+ .s("AWSControlTowerApis", "EnableControl", {})
1451
+ .n("ControlTowerClient", "EnableControlCommand")
1452
+ .f(void 0, void 0)
1453
+ .ser(se_EnableControlCommand)
1454
+ .de(de_EnableControlCommand)
1455
+ .build() {
1456
+ }
1457
+
1458
+ class GetBaselineCommand extends smithyClient.Command
1459
+ .classBuilder()
1460
+ .ep(commonParams)
1461
+ .m(function (Command, cs, config, o) {
1462
+ return [
1463
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1464
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1465
+ ];
1466
+ })
1467
+ .s("AWSControlTowerApis", "GetBaseline", {})
1468
+ .n("ControlTowerClient", "GetBaselineCommand")
1469
+ .f(void 0, void 0)
1470
+ .ser(se_GetBaselineCommand)
1471
+ .de(de_GetBaselineCommand)
1472
+ .build() {
1473
+ }
1474
+
1475
+ class GetBaselineOperationCommand extends smithyClient.Command
1476
+ .classBuilder()
1477
+ .ep(commonParams)
1478
+ .m(function (Command, cs, config, o) {
1479
+ return [
1480
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1481
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1482
+ ];
1483
+ })
1484
+ .s("AWSControlTowerApis", "GetBaselineOperation", {})
1485
+ .n("ControlTowerClient", "GetBaselineOperationCommand")
1486
+ .f(void 0, void 0)
1487
+ .ser(se_GetBaselineOperationCommand)
1488
+ .de(de_GetBaselineOperationCommand)
1489
+ .build() {
1490
+ }
1491
+
1492
+ class GetControlOperationCommand extends smithyClient.Command
1493
+ .classBuilder()
1494
+ .ep(commonParams)
1495
+ .m(function (Command, cs, config, o) {
1496
+ return [
1497
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1498
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1499
+ ];
1500
+ })
1501
+ .s("AWSControlTowerApis", "GetControlOperation", {})
1502
+ .n("ControlTowerClient", "GetControlOperationCommand")
1503
+ .f(void 0, void 0)
1504
+ .ser(se_GetControlOperationCommand)
1505
+ .de(de_GetControlOperationCommand)
1506
+ .build() {
1507
+ }
1508
+
1509
+ class GetEnabledBaselineCommand extends smithyClient.Command
1510
+ .classBuilder()
1511
+ .ep(commonParams)
1512
+ .m(function (Command, cs, config, o) {
1513
+ return [
1514
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1515
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1516
+ ];
1517
+ })
1518
+ .s("AWSControlTowerApis", "GetEnabledBaseline", {})
1519
+ .n("ControlTowerClient", "GetEnabledBaselineCommand")
1520
+ .f(void 0, void 0)
1521
+ .ser(se_GetEnabledBaselineCommand)
1522
+ .de(de_GetEnabledBaselineCommand)
1523
+ .build() {
1524
+ }
1525
+
1526
+ class GetEnabledControlCommand extends smithyClient.Command
1527
+ .classBuilder()
1528
+ .ep(commonParams)
1529
+ .m(function (Command, cs, config, o) {
1530
+ return [
1531
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1532
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1533
+ ];
1534
+ })
1535
+ .s("AWSControlTowerApis", "GetEnabledControl", {})
1536
+ .n("ControlTowerClient", "GetEnabledControlCommand")
1537
+ .f(void 0, void 0)
1538
+ .ser(se_GetEnabledControlCommand)
1539
+ .de(de_GetEnabledControlCommand)
1540
+ .build() {
1541
+ }
1542
+
1543
+ class GetLandingZoneCommand extends smithyClient.Command
1544
+ .classBuilder()
1545
+ .ep(commonParams)
1546
+ .m(function (Command, cs, config, o) {
1547
+ return [
1548
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1549
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1550
+ ];
1551
+ })
1552
+ .s("AWSControlTowerApis", "GetLandingZone", {})
1553
+ .n("ControlTowerClient", "GetLandingZoneCommand")
1554
+ .f(void 0, void 0)
1555
+ .ser(se_GetLandingZoneCommand)
1556
+ .de(de_GetLandingZoneCommand)
1557
+ .build() {
1558
+ }
1559
+
1560
+ class GetLandingZoneOperationCommand extends smithyClient.Command
1561
+ .classBuilder()
1562
+ .ep(commonParams)
1563
+ .m(function (Command, cs, config, o) {
1564
+ return [
1565
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1566
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1567
+ ];
1568
+ })
1569
+ .s("AWSControlTowerApis", "GetLandingZoneOperation", {})
1570
+ .n("ControlTowerClient", "GetLandingZoneOperationCommand")
1571
+ .f(void 0, void 0)
1572
+ .ser(se_GetLandingZoneOperationCommand)
1573
+ .de(de_GetLandingZoneOperationCommand)
1574
+ .build() {
1575
+ }
1576
+
1577
+ class ListBaselinesCommand extends smithyClient.Command
1578
+ .classBuilder()
1579
+ .ep(commonParams)
1580
+ .m(function (Command, cs, config, o) {
1581
+ return [
1582
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1583
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1584
+ ];
1585
+ })
1586
+ .s("AWSControlTowerApis", "ListBaselines", {})
1587
+ .n("ControlTowerClient", "ListBaselinesCommand")
1588
+ .f(void 0, void 0)
1589
+ .ser(se_ListBaselinesCommand)
1590
+ .de(de_ListBaselinesCommand)
1591
+ .build() {
1592
+ }
1593
+
1594
+ class ListControlOperationsCommand extends smithyClient.Command
1595
+ .classBuilder()
1596
+ .ep(commonParams)
1597
+ .m(function (Command, cs, config, o) {
1598
+ return [
1599
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1600
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1601
+ ];
1602
+ })
1603
+ .s("AWSControlTowerApis", "ListControlOperations", {})
1604
+ .n("ControlTowerClient", "ListControlOperationsCommand")
1605
+ .f(void 0, void 0)
1606
+ .ser(se_ListControlOperationsCommand)
1607
+ .de(de_ListControlOperationsCommand)
1608
+ .build() {
1609
+ }
1610
+
1611
+ class ListEnabledBaselinesCommand extends smithyClient.Command
1612
+ .classBuilder()
1613
+ .ep(commonParams)
1614
+ .m(function (Command, cs, config, o) {
1615
+ return [
1616
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1617
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1618
+ ];
1619
+ })
1620
+ .s("AWSControlTowerApis", "ListEnabledBaselines", {})
1621
+ .n("ControlTowerClient", "ListEnabledBaselinesCommand")
1622
+ .f(void 0, void 0)
1623
+ .ser(se_ListEnabledBaselinesCommand)
1624
+ .de(de_ListEnabledBaselinesCommand)
1625
+ .build() {
1626
+ }
1627
+
1628
+ class ListEnabledControlsCommand extends smithyClient.Command
1629
+ .classBuilder()
1630
+ .ep(commonParams)
1631
+ .m(function (Command, cs, config, o) {
1632
+ return [
1633
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1634
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1635
+ ];
1636
+ })
1637
+ .s("AWSControlTowerApis", "ListEnabledControls", {})
1638
+ .n("ControlTowerClient", "ListEnabledControlsCommand")
1639
+ .f(void 0, void 0)
1640
+ .ser(se_ListEnabledControlsCommand)
1641
+ .de(de_ListEnabledControlsCommand)
1642
+ .build() {
1643
+ }
1644
+
1645
+ class ListLandingZoneOperationsCommand extends smithyClient.Command
1646
+ .classBuilder()
1647
+ .ep(commonParams)
1648
+ .m(function (Command, cs, config, o) {
1649
+ return [
1650
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1651
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1652
+ ];
1653
+ })
1654
+ .s("AWSControlTowerApis", "ListLandingZoneOperations", {})
1655
+ .n("ControlTowerClient", "ListLandingZoneOperationsCommand")
1656
+ .f(void 0, void 0)
1657
+ .ser(se_ListLandingZoneOperationsCommand)
1658
+ .de(de_ListLandingZoneOperationsCommand)
1659
+ .build() {
1660
+ }
1661
+
1662
+ class ListLandingZonesCommand extends smithyClient.Command
1663
+ .classBuilder()
1664
+ .ep(commonParams)
1665
+ .m(function (Command, cs, config, o) {
1666
+ return [
1667
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1668
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1669
+ ];
1670
+ })
1671
+ .s("AWSControlTowerApis", "ListLandingZones", {})
1672
+ .n("ControlTowerClient", "ListLandingZonesCommand")
1673
+ .f(void 0, void 0)
1674
+ .ser(se_ListLandingZonesCommand)
1675
+ .de(de_ListLandingZonesCommand)
1676
+ .build() {
1677
+ }
1678
+
1679
+ class ListTagsForResourceCommand extends smithyClient.Command
1680
+ .classBuilder()
1681
+ .ep(commonParams)
1682
+ .m(function (Command, cs, config, o) {
1683
+ return [
1684
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1685
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1686
+ ];
1687
+ })
1688
+ .s("AWSControlTowerApis", "ListTagsForResource", {})
1689
+ .n("ControlTowerClient", "ListTagsForResourceCommand")
1690
+ .f(void 0, void 0)
1691
+ .ser(se_ListTagsForResourceCommand)
1692
+ .de(de_ListTagsForResourceCommand)
1693
+ .build() {
1694
+ }
1695
+
1696
+ class ResetEnabledBaselineCommand extends smithyClient.Command
1697
+ .classBuilder()
1698
+ .ep(commonParams)
1699
+ .m(function (Command, cs, config, o) {
1700
+ return [
1701
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1702
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1703
+ ];
1704
+ })
1705
+ .s("AWSControlTowerApis", "ResetEnabledBaseline", {})
1706
+ .n("ControlTowerClient", "ResetEnabledBaselineCommand")
1707
+ .f(void 0, void 0)
1708
+ .ser(se_ResetEnabledBaselineCommand)
1709
+ .de(de_ResetEnabledBaselineCommand)
1710
+ .build() {
1711
+ }
1712
+
1713
+ class ResetEnabledControlCommand extends smithyClient.Command
1714
+ .classBuilder()
1715
+ .ep(commonParams)
1716
+ .m(function (Command, cs, config, o) {
1717
+ return [
1718
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1719
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1720
+ ];
1721
+ })
1722
+ .s("AWSControlTowerApis", "ResetEnabledControl", {})
1723
+ .n("ControlTowerClient", "ResetEnabledControlCommand")
1724
+ .f(void 0, void 0)
1725
+ .ser(se_ResetEnabledControlCommand)
1726
+ .de(de_ResetEnabledControlCommand)
1727
+ .build() {
1728
+ }
1729
+
1730
+ class ResetLandingZoneCommand extends smithyClient.Command
1731
+ .classBuilder()
1732
+ .ep(commonParams)
1733
+ .m(function (Command, cs, config, o) {
1734
+ return [
1735
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1736
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1737
+ ];
1738
+ })
1739
+ .s("AWSControlTowerApis", "ResetLandingZone", {})
1740
+ .n("ControlTowerClient", "ResetLandingZoneCommand")
1741
+ .f(void 0, void 0)
1742
+ .ser(se_ResetLandingZoneCommand)
1743
+ .de(de_ResetLandingZoneCommand)
1744
+ .build() {
1745
+ }
1746
+
1747
+ class TagResourceCommand extends smithyClient.Command
1748
+ .classBuilder()
1749
+ .ep(commonParams)
1750
+ .m(function (Command, cs, config, o) {
1751
+ return [
1752
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1753
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1754
+ ];
1755
+ })
1756
+ .s("AWSControlTowerApis", "TagResource", {})
1757
+ .n("ControlTowerClient", "TagResourceCommand")
1758
+ .f(void 0, void 0)
1759
+ .ser(se_TagResourceCommand)
1760
+ .de(de_TagResourceCommand)
1761
+ .build() {
1762
+ }
1763
+
1764
+ class UntagResourceCommand extends smithyClient.Command
1765
+ .classBuilder()
1766
+ .ep(commonParams)
1767
+ .m(function (Command, cs, config, o) {
1768
+ return [
1769
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1770
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1771
+ ];
1772
+ })
1773
+ .s("AWSControlTowerApis", "UntagResource", {})
1774
+ .n("ControlTowerClient", "UntagResourceCommand")
1775
+ .f(void 0, void 0)
1776
+ .ser(se_UntagResourceCommand)
1777
+ .de(de_UntagResourceCommand)
1778
+ .build() {
1779
+ }
1780
+
1781
+ class UpdateEnabledBaselineCommand extends smithyClient.Command
1782
+ .classBuilder()
1783
+ .ep(commonParams)
1784
+ .m(function (Command, cs, config, o) {
1785
+ return [
1786
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1787
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1788
+ ];
1789
+ })
1790
+ .s("AWSControlTowerApis", "UpdateEnabledBaseline", {})
1791
+ .n("ControlTowerClient", "UpdateEnabledBaselineCommand")
1792
+ .f(void 0, void 0)
1793
+ .ser(se_UpdateEnabledBaselineCommand)
1794
+ .de(de_UpdateEnabledBaselineCommand)
1795
+ .build() {
1796
+ }
1797
+
1798
+ class UpdateEnabledControlCommand extends smithyClient.Command
1799
+ .classBuilder()
1800
+ .ep(commonParams)
1801
+ .m(function (Command, cs, config, o) {
1802
+ return [
1803
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1804
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1805
+ ];
1806
+ })
1807
+ .s("AWSControlTowerApis", "UpdateEnabledControl", {})
1808
+ .n("ControlTowerClient", "UpdateEnabledControlCommand")
1809
+ .f(void 0, void 0)
1810
+ .ser(se_UpdateEnabledControlCommand)
1811
+ .de(de_UpdateEnabledControlCommand)
1812
+ .build() {
1813
+ }
1814
+
1815
+ class UpdateLandingZoneCommand extends smithyClient.Command
1816
+ .classBuilder()
1817
+ .ep(commonParams)
1818
+ .m(function (Command, cs, config, o) {
1819
+ return [
1820
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1821
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1822
+ ];
1823
+ })
1824
+ .s("AWSControlTowerApis", "UpdateLandingZone", {})
1825
+ .n("ControlTowerClient", "UpdateLandingZoneCommand")
1826
+ .f(void 0, void 0)
1827
+ .ser(se_UpdateLandingZoneCommand)
1828
+ .de(de_UpdateLandingZoneCommand)
1829
+ .build() {
1830
+ }
1831
+
1832
+ const commands = {
1833
+ CreateLandingZoneCommand,
1834
+ DeleteLandingZoneCommand,
1835
+ DisableBaselineCommand,
1836
+ DisableControlCommand,
1837
+ EnableBaselineCommand,
1838
+ EnableControlCommand,
1839
+ GetBaselineCommand,
1840
+ GetBaselineOperationCommand,
1841
+ GetControlOperationCommand,
1842
+ GetEnabledBaselineCommand,
1843
+ GetEnabledControlCommand,
1844
+ GetLandingZoneCommand,
1845
+ GetLandingZoneOperationCommand,
1846
+ ListBaselinesCommand,
1847
+ ListControlOperationsCommand,
1848
+ ListEnabledBaselinesCommand,
1849
+ ListEnabledControlsCommand,
1850
+ ListLandingZoneOperationsCommand,
1851
+ ListLandingZonesCommand,
1852
+ ListTagsForResourceCommand,
1853
+ ResetEnabledBaselineCommand,
1854
+ ResetEnabledControlCommand,
1855
+ ResetLandingZoneCommand,
1856
+ TagResourceCommand,
1857
+ UntagResourceCommand,
1858
+ UpdateEnabledBaselineCommand,
1859
+ UpdateEnabledControlCommand,
1860
+ UpdateLandingZoneCommand,
1861
+ };
1862
+ class ControlTower extends ControlTowerClient {
1863
+ }
1864
+ smithyClient.createAggregatedClient(commands, ControlTower);
2002
1865
 
2003
- // src/ControlTower.ts
2004
- var commands = {
2005
- CreateLandingZoneCommand,
2006
- DeleteLandingZoneCommand,
2007
- DisableBaselineCommand,
2008
- DisableControlCommand,
2009
- EnableBaselineCommand,
2010
- EnableControlCommand,
2011
- GetBaselineCommand,
2012
- GetBaselineOperationCommand,
2013
- GetControlOperationCommand,
2014
- GetEnabledBaselineCommand,
2015
- GetEnabledControlCommand,
2016
- GetLandingZoneCommand,
2017
- GetLandingZoneOperationCommand,
2018
- ListBaselinesCommand,
2019
- ListControlOperationsCommand,
2020
- ListEnabledBaselinesCommand,
2021
- ListEnabledControlsCommand,
2022
- ListLandingZoneOperationsCommand,
2023
- ListLandingZonesCommand,
2024
- ListTagsForResourceCommand,
2025
- ResetEnabledBaselineCommand,
2026
- ResetEnabledControlCommand,
2027
- ResetLandingZoneCommand,
2028
- TagResourceCommand,
2029
- UntagResourceCommand,
2030
- UpdateEnabledBaselineCommand,
2031
- UpdateEnabledControlCommand,
2032
- UpdateLandingZoneCommand
2033
- };
2034
- var ControlTower = class extends ControlTowerClient {
2035
- static {
2036
- __name(this, "ControlTower");
2037
- }
2038
- };
2039
- (0, import_smithy_client.createAggregatedClient)(commands, ControlTower);
2040
-
2041
- // src/pagination/ListBaselinesPaginator.ts
2042
-
2043
- var paginateListBaselines = (0, import_core.createPaginator)(ControlTowerClient, ListBaselinesCommand, "nextToken", "nextToken", "maxResults");
2044
-
2045
- // src/pagination/ListControlOperationsPaginator.ts
2046
-
2047
- var paginateListControlOperations = (0, import_core.createPaginator)(ControlTowerClient, ListControlOperationsCommand, "nextToken", "nextToken", "maxResults");
2048
-
2049
- // src/pagination/ListEnabledBaselinesPaginator.ts
2050
-
2051
- var paginateListEnabledBaselines = (0, import_core.createPaginator)(ControlTowerClient, ListEnabledBaselinesCommand, "nextToken", "nextToken", "maxResults");
2052
-
2053
- // src/pagination/ListEnabledControlsPaginator.ts
1866
+ const paginateListBaselines = core.createPaginator(ControlTowerClient, ListBaselinesCommand, "nextToken", "nextToken", "maxResults");
2054
1867
 
2055
- var paginateListEnabledControls = (0, import_core.createPaginator)(ControlTowerClient, ListEnabledControlsCommand, "nextToken", "nextToken", "maxResults");
1868
+ const paginateListControlOperations = core.createPaginator(ControlTowerClient, ListControlOperationsCommand, "nextToken", "nextToken", "maxResults");
2056
1869
 
2057
- // src/pagination/ListLandingZoneOperationsPaginator.ts
1870
+ const paginateListEnabledBaselines = core.createPaginator(ControlTowerClient, ListEnabledBaselinesCommand, "nextToken", "nextToken", "maxResults");
2058
1871
 
2059
- var paginateListLandingZoneOperations = (0, import_core.createPaginator)(ControlTowerClient, ListLandingZoneOperationsCommand, "nextToken", "nextToken", "maxResults");
1872
+ const paginateListEnabledControls = core.createPaginator(ControlTowerClient, ListEnabledControlsCommand, "nextToken", "nextToken", "maxResults");
2060
1873
 
2061
- // src/pagination/ListLandingZonesPaginator.ts
1874
+ const paginateListLandingZoneOperations = core.createPaginator(ControlTowerClient, ListLandingZoneOperationsCommand, "nextToken", "nextToken", "maxResults");
2062
1875
 
2063
- var paginateListLandingZones = (0, import_core.createPaginator)(ControlTowerClient, ListLandingZonesCommand, "nextToken", "nextToken", "maxResults");
2064
- // Annotate the CommonJS export names for ESM import in node:
1876
+ const paginateListLandingZones = core.createPaginator(ControlTowerClient, ListLandingZonesCommand, "nextToken", "nextToken", "maxResults");
2065
1877
 
2066
- 0 && (module.exports = {
2067
- ControlTowerServiceException,
2068
- __Client,
2069
- ControlTowerClient,
2070
- ControlTower,
2071
- $Command,
2072
- CreateLandingZoneCommand,
2073
- DeleteLandingZoneCommand,
2074
- DisableBaselineCommand,
2075
- DisableControlCommand,
2076
- EnableBaselineCommand,
2077
- EnableControlCommand,
2078
- GetBaselineCommand,
2079
- GetBaselineOperationCommand,
2080
- GetControlOperationCommand,
2081
- GetEnabledBaselineCommand,
2082
- GetEnabledControlCommand,
2083
- GetLandingZoneCommand,
2084
- GetLandingZoneOperationCommand,
2085
- ListBaselinesCommand,
2086
- ListControlOperationsCommand,
2087
- ListEnabledBaselinesCommand,
2088
- ListEnabledControlsCommand,
2089
- ListLandingZoneOperationsCommand,
2090
- ListLandingZonesCommand,
2091
- ListTagsForResourceCommand,
2092
- ResetEnabledBaselineCommand,
2093
- ResetEnabledControlCommand,
2094
- ResetLandingZoneCommand,
2095
- TagResourceCommand,
2096
- UntagResourceCommand,
2097
- UpdateEnabledBaselineCommand,
2098
- UpdateEnabledControlCommand,
2099
- UpdateLandingZoneCommand,
2100
- paginateListBaselines,
2101
- paginateListControlOperations,
2102
- paginateListEnabledBaselines,
2103
- paginateListEnabledControls,
2104
- paginateListLandingZoneOperations,
2105
- paginateListLandingZones,
2106
- AccessDeniedException,
2107
- BaselineOperationType,
2108
- BaselineOperationStatus,
2109
- InternalServerException,
2110
- ResourceNotFoundException,
2111
- ThrottlingException,
2112
- ValidationException,
2113
- ControlOperationType,
2114
- ControlOperationStatus,
2115
- ConflictException,
2116
- ServiceQuotaExceededException,
2117
- EnabledBaselineDriftStatus,
2118
- EnablementStatus,
2119
- DriftStatus,
2120
- LandingZoneOperationType,
2121
- LandingZoneOperationStatus,
2122
- LandingZoneDriftStatus,
2123
- LandingZoneStatus
1878
+ Object.defineProperty(exports, "$Command", {
1879
+ enumerable: true,
1880
+ get: function () { return smithyClient.Command; }
2124
1881
  });
2125
-
1882
+ Object.defineProperty(exports, "__Client", {
1883
+ enumerable: true,
1884
+ get: function () { return smithyClient.Client; }
1885
+ });
1886
+ exports.AccessDeniedException = AccessDeniedException;
1887
+ exports.BaselineOperationStatus = BaselineOperationStatus;
1888
+ exports.BaselineOperationType = BaselineOperationType;
1889
+ exports.ConflictException = ConflictException;
1890
+ exports.ControlOperationStatus = ControlOperationStatus;
1891
+ exports.ControlOperationType = ControlOperationType;
1892
+ exports.ControlTower = ControlTower;
1893
+ exports.ControlTowerClient = ControlTowerClient;
1894
+ exports.ControlTowerServiceException = ControlTowerServiceException;
1895
+ exports.CreateLandingZoneCommand = CreateLandingZoneCommand;
1896
+ exports.DeleteLandingZoneCommand = DeleteLandingZoneCommand;
1897
+ exports.DisableBaselineCommand = DisableBaselineCommand;
1898
+ exports.DisableControlCommand = DisableControlCommand;
1899
+ exports.DriftStatus = DriftStatus;
1900
+ exports.EnableBaselineCommand = EnableBaselineCommand;
1901
+ exports.EnableControlCommand = EnableControlCommand;
1902
+ exports.EnabledBaselineDriftStatus = EnabledBaselineDriftStatus;
1903
+ exports.EnablementStatus = EnablementStatus;
1904
+ exports.GetBaselineCommand = GetBaselineCommand;
1905
+ exports.GetBaselineOperationCommand = GetBaselineOperationCommand;
1906
+ exports.GetControlOperationCommand = GetControlOperationCommand;
1907
+ exports.GetEnabledBaselineCommand = GetEnabledBaselineCommand;
1908
+ exports.GetEnabledControlCommand = GetEnabledControlCommand;
1909
+ exports.GetLandingZoneCommand = GetLandingZoneCommand;
1910
+ exports.GetLandingZoneOperationCommand = GetLandingZoneOperationCommand;
1911
+ exports.InternalServerException = InternalServerException;
1912
+ exports.LandingZoneDriftStatus = LandingZoneDriftStatus;
1913
+ exports.LandingZoneOperationStatus = LandingZoneOperationStatus;
1914
+ exports.LandingZoneOperationType = LandingZoneOperationType;
1915
+ exports.LandingZoneStatus = LandingZoneStatus;
1916
+ exports.ListBaselinesCommand = ListBaselinesCommand;
1917
+ exports.ListControlOperationsCommand = ListControlOperationsCommand;
1918
+ exports.ListEnabledBaselinesCommand = ListEnabledBaselinesCommand;
1919
+ exports.ListEnabledControlsCommand = ListEnabledControlsCommand;
1920
+ exports.ListLandingZoneOperationsCommand = ListLandingZoneOperationsCommand;
1921
+ exports.ListLandingZonesCommand = ListLandingZonesCommand;
1922
+ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
1923
+ exports.ResetEnabledBaselineCommand = ResetEnabledBaselineCommand;
1924
+ exports.ResetEnabledControlCommand = ResetEnabledControlCommand;
1925
+ exports.ResetLandingZoneCommand = ResetLandingZoneCommand;
1926
+ exports.ResourceNotFoundException = ResourceNotFoundException;
1927
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1928
+ exports.TagResourceCommand = TagResourceCommand;
1929
+ exports.ThrottlingException = ThrottlingException;
1930
+ exports.UntagResourceCommand = UntagResourceCommand;
1931
+ exports.UpdateEnabledBaselineCommand = UpdateEnabledBaselineCommand;
1932
+ exports.UpdateEnabledControlCommand = UpdateEnabledControlCommand;
1933
+ exports.UpdateLandingZoneCommand = UpdateLandingZoneCommand;
1934
+ exports.ValidationException = ValidationException;
1935
+ exports.paginateListBaselines = paginateListBaselines;
1936
+ exports.paginateListControlOperations = paginateListControlOperations;
1937
+ exports.paginateListEnabledBaselines = paginateListEnabledBaselines;
1938
+ exports.paginateListEnabledControls = paginateListEnabledControls;
1939
+ exports.paginateListLandingZoneOperations = paginateListLandingZoneOperations;
1940
+ exports.paginateListLandingZones = paginateListLandingZones;