@aws-sdk/client-controltower 3.927.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class ControlTowerClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class ControlTowerClient extends smithyClient.Client {
     }
 }
 
-class ControlTowerServiceException extends smithyClient.ServiceException {
+let ControlTowerServiceException$1 = class ControlTowerServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, ControlTowerServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends ControlTowerServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends ControlTowerServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -128,7 +128,7 @@ class AccessDeniedException extends ControlTowerServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const BaselineOperationType = {
     DISABLE_BASELINE: "DISABLE_BASELINE",
     ENABLE_BASELINE: "ENABLE_BASELINE",
@@ -140,7 +140,7 @@ const BaselineOperationStatus = {
     IN_PROGRESS: "IN_PROGRESS",
     SUCCEEDED: "SUCCEEDED",
 };
-class InternalServerException extends ControlTowerServiceException {
+let InternalServerException$1 = class InternalServerException extends ControlTowerServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -152,8 +152,8 @@ class InternalServerException extends ControlTowerServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends ControlTowerServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends ControlTowerServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -164,8 +164,8 @@ class ResourceNotFoundException extends ControlTowerServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ThrottlingException extends ControlTowerServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends ControlTowerServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {
@@ -185,8 +185,8 @@ class ThrottlingException extends ControlTowerServiceException {
         this.quotaCode = opts.quotaCode;
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
-}
-class ValidationException extends ControlTowerServiceException {
+};
+let ValidationException$1 = class ValidationException extends ControlTowerServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -197,7 +197,7 @@ class ValidationException extends ControlTowerServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
+};
 const ControlOperationType = {
     DISABLE_CONTROL: "DISABLE_CONTROL",
     ENABLE_CONTROL: "ENABLE_CONTROL",
@@ -209,7 +209,7 @@ const ControlOperationStatus = {
     IN_PROGRESS: "IN_PROGRESS",
     SUCCEEDED: "SUCCEEDED",
 };
-class ConflictException extends ControlTowerServiceException {
+let ConflictException$1 = class ConflictException extends ControlTowerServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -220,8 +220,8 @@ class ConflictException extends ControlTowerServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
-class ServiceQuotaExceededException extends ControlTowerServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends ControlTowerServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     constructor(opts) {
@@ -232,7 +232,7 @@ class ServiceQuotaExceededException extends ControlTowerServiceException {
         });
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
-}
+};
 const EnabledBaselineDriftStatus = {
     DRIFTED: "DRIFTED",
     IN_SYNC: "IN_SYNC",
@@ -272,1110 +272,951 @@ const LandingZoneStatus = {
     PROCESSING: "PROCESSING",
 };
 
-const se_CreateLandingZoneCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/create-landingzone");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        manifest: (_) => se_Manifest(_),
-        remediationTypes: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-        version: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteLandingZoneCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/delete-landingzone");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        landingZoneIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DisableBaselineCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/disable-baseline");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        enabledBaselineIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DisableControlCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/disable-control");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        controlIdentifier: [],
-        enabledControlIdentifier: [],
-        targetIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_EnableBaselineCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/enable-baseline");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        baselineIdentifier: [],
-        baselineVersion: [],
-        parameters: (_) => se_EnabledBaselineParameters(_),
-        tags: (_) => smithyClient._json(_),
-        targetIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_EnableControlCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/enable-control");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        controlIdentifier: [],
-        parameters: (_) => se_EnabledControlParameters(_),
-        tags: (_) => smithyClient._json(_),
-        targetIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetBaselineCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/get-baseline");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        baselineIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetBaselineOperationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/get-baseline-operation");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        operationIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetControlOperationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/get-control-operation");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        operationIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetEnabledBaselineCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/get-enabled-baseline");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        enabledBaselineIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetEnabledControlCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/get-enabled-control");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        enabledControlIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetLandingZoneCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/get-landingzone");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        landingZoneIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetLandingZoneOperationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/get-landingzone-operation");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        operationIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListBaselinesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-baselines");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListControlOperationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-control-operations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filter: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListEnabledBaselinesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-enabled-baselines");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filter: (_) => smithyClient._json(_),
-        includeChildren: [],
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListEnabledControlsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-enabled-controls");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filter: (_) => smithyClient._json(_),
-        includeChildren: [],
-        maxResults: [],
-        nextToken: [],
-        targetIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListLandingZoneOperationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-landingzone-operations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        filter: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListLandingZonesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-landingzones");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ResetEnabledBaselineCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/reset-enabled-baseline");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        enabledBaselineIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ResetEnabledControlCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/reset-enabled-control");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        enabledControlIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ResetLandingZoneCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/reset-landingzone");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        landingZoneIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateEnabledBaselineCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/update-enabled-baseline");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        baselineVersion: [],
-        enabledBaselineIdentifier: [],
-        parameters: (_) => se_EnabledBaselineParameters(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateEnabledControlCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/update-enabled-control");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        enabledControlIdentifier: [],
-        parameters: (_) => se_EnabledControlParameters(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateLandingZoneCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/update-landingzone");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        landingZoneIdentifier: [],
-        manifest: (_) => se_Manifest(_),
-        remediationTypes: (_) => smithyClient._json(_),
-        version: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CreateLandingZoneCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        arn: smithyClient.expectString,
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteLandingZoneCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DisableBaselineCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DisableControlCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_EnableBaselineCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        arn: smithyClient.expectString,
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_EnableControlCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        arn: smithyClient.expectString,
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetBaselineCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        arn: smithyClient.expectString,
-        description: smithyClient.expectString,
-        name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetBaselineOperationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        baselineOperation: (_) => de_BaselineOperation(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetControlOperationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        controlOperation: (_) => de_ControlOperation(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetEnabledBaselineCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        enabledBaselineDetails: (_) => de_EnabledBaselineDetails(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetEnabledControlCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        enabledControlDetails: (_) => de_EnabledControlDetails(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetLandingZoneCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        landingZone: (_) => de_LandingZoneDetail(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetLandingZoneOperationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationDetails: (_) => de_LandingZoneOperationDetail(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListBaselinesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        baselines: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListControlOperationsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        controlOperations: (_) => de_ControlOperations(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListEnabledBaselinesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        enabledBaselines: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListEnabledControlsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        enabledControls: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListLandingZoneOperationsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        landingZoneOperations: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListLandingZonesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        landingZones: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ResetEnabledBaselineCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ResetEnabledControlCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ResetLandingZoneCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateEnabledBaselineCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateEnabledControlCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateLandingZoneCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        operationIdentifier: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.controltower#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.controltower#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.controltower#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.controltower#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.controltower#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.controltower#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.controltower#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(ControlTowerServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
-    });
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        quotaCode: smithyClient.expectString,
-        serviceCode: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_EnabledBaselineParameter = (input, context) => {
-    return smithyClient.take(input, {
-        key: [],
-        value: (_) => se_EnabledBaselineParameterDocument(_),
-    });
-};
-const se_EnabledBaselineParameterDocument = (input, context) => {
-    return input;
-};
-const se_EnabledBaselineParameters = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_EnabledBaselineParameter(entry);
-    });
-};
-const se_EnabledControlParameter = (input, context) => {
-    return smithyClient.take(input, {
-        key: [],
-        value: (_) => se_Document(_),
-    });
-};
-const se_EnabledControlParameters = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_EnabledControlParameter(entry);
-    });
-};
-const se_Manifest = (input, context) => {
-    return input;
-};
-const se_Document = (input, context) => {
-    return input;
-};
-const de_BaselineOperation = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        operationIdentifier: smithyClient.expectString,
-        operationType: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        status: smithyClient.expectString,
-        statusMessage: smithyClient.expectString,
-    });
-};
-const de_ControlOperation = (output, context) => {
-    return smithyClient.take(output, {
-        controlIdentifier: smithyClient.expectString,
-        enabledControlIdentifier: smithyClient.expectString,
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        operationIdentifier: smithyClient.expectString,
-        operationType: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        status: smithyClient.expectString,
-        statusMessage: smithyClient.expectString,
-        targetIdentifier: smithyClient.expectString,
-    });
-};
-const de_ControlOperations = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ControlOperationSummary(entry);
-    });
-    return retVal;
-};
-const de_ControlOperationSummary = (output, context) => {
-    return smithyClient.take(output, {
-        controlIdentifier: smithyClient.expectString,
-        enabledControlIdentifier: smithyClient.expectString,
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        operationIdentifier: smithyClient.expectString,
-        operationType: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        status: smithyClient.expectString,
-        statusMessage: smithyClient.expectString,
-        targetIdentifier: smithyClient.expectString,
-    });
-};
-const de_EnabledBaselineDetails = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        baselineIdentifier: smithyClient.expectString,
-        baselineVersion: smithyClient.expectString,
-        driftStatusSummary: smithyClient._json,
-        parameters: (_) => de_EnabledBaselineParameterSummaries(_),
-        parentIdentifier: smithyClient.expectString,
-        statusSummary: smithyClient._json,
-        targetIdentifier: smithyClient.expectString,
-    });
-};
-const de_EnabledBaselineParameterDocument = (output, context) => {
-    return output;
-};
-const de_EnabledBaselineParameterSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_EnabledBaselineParameterSummary(entry);
-    });
-    return retVal;
-};
-const de_EnabledBaselineParameterSummary = (output, context) => {
-    return smithyClient.take(output, {
-        key: smithyClient.expectString,
-        value: (_) => de_EnabledBaselineParameterDocument(_),
-    });
-};
-const de_EnabledControlDetails = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        controlIdentifier: smithyClient.expectString,
-        driftStatusSummary: smithyClient._json,
-        parameters: (_) => de_EnabledControlParameterSummaries(_),
-        parentIdentifier: smithyClient.expectString,
-        statusSummary: smithyClient._json,
-        targetIdentifier: smithyClient.expectString,
-        targetRegions: smithyClient._json,
-    });
-};
-const de_EnabledControlParameterSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_EnabledControlParameterSummary(entry);
-    });
-    return retVal;
-};
-const de_EnabledControlParameterSummary = (output, context) => {
-    return smithyClient.take(output, {
-        key: smithyClient.expectString,
-        value: (_) => de_Document(_),
-    });
-};
-const de_LandingZoneDetail = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        driftStatus: smithyClient._json,
-        latestAvailableVersion: smithyClient.expectString,
-        manifest: (_) => de_Manifest(_),
-        remediationTypes: smithyClient._json,
-        status: smithyClient.expectString,
-        version: smithyClient.expectString,
-    });
-};
-const de_LandingZoneOperationDetail = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        operationIdentifier: smithyClient.expectString,
-        operationType: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        status: smithyClient.expectString,
-        statusMessage: smithyClient.expectString,
-    });
-};
-const de_Manifest = (output, context) => {
-    return output;
-};
-const de_Document = (output, context) => {
-    return output;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _ADE = "AccessDeniedException";
+const _B = "Baselines";
+const _BO = "BaselineOperation";
+const _BS = "BaselineSummary";
+const _CE = "ConflictException";
+const _CLZ = "CreateLandingZone";
+const _CLZI = "CreateLandingZoneInput";
+const _CLZO = "CreateLandingZoneOutput";
+const _CO = "ControlOperation";
+const _COF = "ControlOperationFilter";
+const _COS = "ControlOperationSummary";
+const _COo = "ControlOperations";
+const _DB = "DisableBaseline";
+const _DBI = "DisableBaselineInput";
+const _DBO = "DisableBaselineOutput";
+const _DC = "DisableControl";
+const _DCI = "DisableControlInput";
+const _DCO = "DisableControlOutput";
+const _DLZ = "DeleteLandingZone";
+const _DLZI = "DeleteLandingZoneInput";
+const _DLZO = "DeleteLandingZoneOutput";
+const _DSS = "DriftStatusSummary";
+const _EB = "EnabledBaselines";
+const _EBD = "EnabledBaselineDetails";
+const _EBDSS = "EnabledBaselineDriftStatusSummary";
+const _EBDT = "EnabledBaselineDriftTypes";
+const _EBF = "EnabledBaselineFilter";
+const _EBI = "EnableBaselineInput";
+const _EBID = "EnabledBaselineInheritanceDrift";
+const _EBO = "EnableBaselineOutput";
+const _EBP = "EnabledBaselineParameter";
+const _EBPS = "EnabledBaselineParameterSummary";
+const _EBPSn = "EnabledBaselineParameterSummaries";
+const _EBPn = "EnabledBaselineParameters";
+const _EBS = "EnabledBaselineSummary";
+const _EBn = "EnableBaseline";
+const _EC = "EnabledControls";
+const _ECD = "EnabledControlDetails";
+const _ECDT = "EnabledControlDriftTypes";
+const _ECF = "EnabledControlFilter";
+const _ECI = "EnableControlInput";
+const _ECID = "EnabledControlInheritanceDrift";
+const _ECO = "EnableControlOutput";
+const _ECP = "EnabledControlParameter";
+const _ECPS = "EnabledControlParameterSummary";
+const _ECPSn = "EnabledControlParameterSummaries";
+const _ECPn = "EnabledControlParameters";
+const _ECRD = "EnabledControlResourceDrift";
+const _ECS = "EnabledControlSummary";
+const _ECn = "EnableControl";
+const _ESS = "EnablementStatusSummary";
+const _GB = "GetBaseline";
+const _GBI = "GetBaselineInput";
+const _GBO = "GetBaselineOutput";
+const _GBOI = "GetBaselineOperationInput";
+const _GBOO = "GetBaselineOperationOutput";
+const _GBOe = "GetBaselineOperation";
+const _GCO = "GetControlOperation";
+const _GCOI = "GetControlOperationInput";
+const _GCOO = "GetControlOperationOutput";
+const _GEB = "GetEnabledBaseline";
+const _GEBI = "GetEnabledBaselineInput";
+const _GEBO = "GetEnabledBaselineOutput";
+const _GEC = "GetEnabledControl";
+const _GECI = "GetEnabledControlInput";
+const _GECO = "GetEnabledControlOutput";
+const _GLZ = "GetLandingZone";
+const _GLZI = "GetLandingZoneInput";
+const _GLZO = "GetLandingZoneOutput";
+const _GLZOI = "GetLandingZoneOperationInput";
+const _GLZOO = "GetLandingZoneOperationOutput";
+const _GLZOe = "GetLandingZoneOperation";
+const _ISE = "InternalServerException";
+const _LB = "ListBaselines";
+const _LBI = "ListBaselinesInput";
+const _LBO = "ListBaselinesOutput";
+const _LCO = "ListControlOperations";
+const _LCOI = "ListControlOperationsInput";
+const _LCOO = "ListControlOperationsOutput";
+const _LEB = "ListEnabledBaselines";
+const _LEBI = "ListEnabledBaselinesInput";
+const _LEBO = "ListEnabledBaselinesOutput";
+const _LEC = "ListEnabledControls";
+const _LECI = "ListEnabledControlsInput";
+const _LECO = "ListEnabledControlsOutput";
+const _LLZ = "ListLandingZones";
+const _LLZI = "ListLandingZonesInput";
+const _LLZO = "ListLandingZonesOutput";
+const _LLZOI = "ListLandingZoneOperationsInput";
+const _LLZOO = "ListLandingZoneOperationsOutput";
+const _LLZOi = "ListLandingZoneOperations";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _LZD = "LandingZoneDetail";
+const _LZDSS = "LandingZoneDriftStatusSummary";
+const _LZO = "LandingZoneOperations";
+const _LZOD = "LandingZoneOperationDetail";
+const _LZOF = "LandingZoneOperationFilter";
+const _LZOS = "LandingZoneOperationSummary";
+const _LZS = "LandingZoneSummary";
+const _LZSa = "LandingZoneSummaries";
+const _R = "Region";
+const _RA = "Retry-After";
+const _REB = "ResetEnabledBaseline";
+const _REBI = "ResetEnabledBaselineInput";
+const _REBO = "ResetEnabledBaselineOutput";
+const _REC = "ResetEnabledControl";
+const _RECI = "ResetEnabledControlInput";
+const _RECO = "ResetEnabledControlOutput";
+const _RLZ = "ResetLandingZone";
+const _RLZI = "ResetLandingZoneInput";
+const _RLZO = "ResetLandingZoneOutput";
+const _RNFE = "ResourceNotFoundException";
+const _SQEE = "ServiceQuotaExceededException";
+const _TE = "ThrottlingException";
+const _TR = "TargetRegions";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _TRa = "TagResource";
+const _UEB = "UpdateEnabledBaseline";
+const _UEBI = "UpdateEnabledBaselineInput";
+const _UEBO = "UpdateEnabledBaselineOutput";
+const _UEC = "UpdateEnabledControl";
+const _UECI = "UpdateEnabledControlInput";
+const _UECO = "UpdateEnabledControlOutput";
+const _ULZ = "UpdateLandingZone";
+const _ULZI = "UpdateLandingZoneInput";
+const _ULZO = "UpdateLandingZoneOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _VE = "ValidationException";
+const _a = "arn";
+const _b = "baselines";
+const _bI = "baselineIdentifier";
+const _bIa = "baselineIdentifiers";
+const _bO = "baselineOperation";
+const _bV = "baselineVersion";
+const _c = "client";
+const _cI = "controlIdentifier";
+const _cIo = "controlIdentifiers";
+const _cO = "controlOperation";
+const _cOT = "controlOperationTypes";
+const _cOo = "controlOperations";
+const _d = "description";
+const _dS = "driftStatus";
+const _dSS = "driftStatusSummary";
+const _dSr = "driftStatuses";
+const _e = "error";
+const _eB = "enabledBaselines";
+const _eBD = "enabledBaselineDetails";
+const _eBI = "enabledBaselineIdentifier";
+const _eC = "enabledControls";
+const _eCD = "enabledControlDetails";
+const _eCI = "enabledControlIdentifier";
+const _eCIn = "enabledControlIdentifiers";
+const _eT = "endTime";
+const _f = "filter";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _i = "inheritance";
+const _iC = "includeChildren";
+const _iDS = "inheritanceDriftStatuses";
+const _k = "key";
+const _lAV = "latestAvailableVersion";
+const _lOI = "lastOperationIdentifier";
+const _lZ = "landingZone";
+const _lZI = "landingZoneIdentifier";
+const _lZO = "landingZoneOperations";
+const _lZa = "landingZones";
+const _m = "message";
+const _mR = "maxResults";
+const _ma = "manifest";
+const _n = "name";
+const _nT = "nextToken";
+const _oD = "operationDetails";
+const _oI = "operationIdentifier";
+const _oT = "operationType";
+const _p = "parameters";
+const _pI = "parentIdentifier";
+const _pIa = "parentIdentifiers";
+const _qC = "quotaCode";
+const _r = "resource";
+const _rA = "resourceArn";
 const _rAS = "retryAfterSeconds";
-const _ra = "retry-after";
+const _rDS = "resourceDriftStatuses";
+const _rT = "remediationTypes";
+const _s = "status";
+const _sC = "serviceCode";
+const _sM = "statusMessage";
+const _sS = "statusSummary";
+const _sT = "startTime";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.controltower";
+const _st = "statuses";
+const _t = "tags";
+const _tI = "targetIdentifier";
+const _tIa = "targetIdentifiers";
 const _tK = "tagKeys";
+const _tR = "targetRegions";
+const _ty = "types";
+const _v = "version";
+const _va = "value";
+const n0 = "com.amazonaws.controltower";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var BaselineOperation = [
+    3,
+    n0,
+    _BO,
+    0,
+    [_oI, _oT, _s, _sT, _eT, _sM],
+    [0, 0, 0, 5, 5, 0],
+];
+var BaselineSummary = [3, n0, _BS, 0, [_a, _n, _d], [0, 0, 0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var ControlOperation = [
+    3,
+    n0,
+    _CO,
+    0,
+    [_oT, _sT, _eT, _s, _sM, _oI, _cI, _tI, _eCI],
+    [0, 5, 5, 0, 0, 0, 0, 0, 0],
+];
+var ControlOperationFilter = [
+    3,
+    n0,
+    _COF,
+    0,
+    [_cIo, _tIa, _eCIn, _st, _cOT],
+    [64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0],
+];
+var ControlOperationSummary = [
+    3,
+    n0,
+    _COS,
+    0,
+    [_oT, _sT, _eT, _s, _sM, _oI, _cI, _tI, _eCI],
+    [0, 5, 5, 0, 0, 0, 0, 0, 0],
+];
+var CreateLandingZoneInput = [
+    3,
+    n0,
+    _CLZI,
+    0,
+    [_v, _ma, _rT, _t],
+    [0, 15, 64 | 0, 128 | 0],
+];
+var CreateLandingZoneOutput = [3, n0, _CLZO, 0, [_a, _oI], [0, 0]];
+var DeleteLandingZoneInput = [3, n0, _DLZI, 0, [_lZI], [0]];
+var DeleteLandingZoneOutput = [3, n0, _DLZO, 0, [_oI], [0]];
+var DisableBaselineInput = [3, n0, _DBI, 0, [_eBI], [0]];
+var DisableBaselineOutput = [3, n0, _DBO, 0, [_oI], [0]];
+var DisableControlInput = [3, n0, _DCI, 0, [_cI, _tI, _eCI], [0, 0, 0]];
+var DisableControlOutput = [3, n0, _DCO, 0, [_oI], [0]];
+var DriftStatusSummary = [
+    3,
+    n0,
+    _DSS,
+    0,
+    [_dS, _ty],
+    [0, () => EnabledControlDriftTypes],
+];
+var EnableBaselineInput = [
+    3,
+    n0,
+    _EBI,
+    0,
+    [_bV, _p, _bI, _tI, _t],
+    [0, () => EnabledBaselineParameters, 0, 0, 128 | 0],
+];
+var EnableBaselineOutput = [3, n0, _EBO, 0, [_oI, _a], [0, 0]];
+var EnableControlInput = [
+    3,
+    n0,
+    _ECI,
+    0,
+    [_cI, _tI, _t, _p],
+    [0, 0, 128 | 0, () => EnabledControlParameters],
+];
+var EnableControlOutput = [3, n0, _ECO, 0, [_oI, _a], [0, 0]];
+var EnabledBaselineDetails = [
+    3,
+    n0,
+    _EBD,
+    0,
+    [_a, _bI, _bV, _dSS, _tI, _pI, _sS, _p],
+    [
+        0,
+        0,
+        0,
+        () => EnabledBaselineDriftStatusSummary,
+        0,
+        0,
+        () => EnablementStatusSummary,
+        () => EnabledBaselineParameterSummaries,
+    ],
+];
+var EnabledBaselineDriftStatusSummary = [
+    3,
+    n0,
+    _EBDSS,
+    0,
+    [_ty],
+    [() => EnabledBaselineDriftTypes],
+];
+var EnabledBaselineDriftTypes = [
+    3,
+    n0,
+    _EBDT,
+    0,
+    [_i],
+    [() => EnabledBaselineInheritanceDrift],
+];
+var EnabledBaselineFilter = [
+    3,
+    n0,
+    _EBF,
+    0,
+    [_tIa, _bIa, _pIa, _st, _iDS],
+    [64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0],
+];
+var EnabledBaselineInheritanceDrift = [3, n0, _EBID, 0, [_s], [0]];
+var EnabledBaselineParameter = [3, n0, _EBP, 0, [_k, _va], [0, 15]];
+var EnabledBaselineParameterSummary = [3, n0, _EBPS, 0, [_k, _va], [0, 15]];
+var EnabledBaselineSummary = [
+    3,
+    n0,
+    _EBS,
+    0,
+    [_a, _bI, _bV, _dSS, _tI, _pI, _sS],
+    [0, 0, 0, () => EnabledBaselineDriftStatusSummary, 0, 0, () => EnablementStatusSummary],
+];
+var EnabledControlDetails = [
+    3,
+    n0,
+    _ECD,
+    0,
+    [_a, _cI, _tI, _sS, _dSS, _pI, _tR, _p],
+    [
+        0,
+        0,
+        0,
+        () => EnablementStatusSummary,
+        () => DriftStatusSummary,
+        0,
+        () => TargetRegions,
+        () => EnabledControlParameterSummaries,
+    ],
+];
+var EnabledControlDriftTypes = [
+    3,
+    n0,
+    _ECDT,
+    0,
+    [_i, _r],
+    [() => EnabledControlInheritanceDrift, () => EnabledControlResourceDrift],
+];
+var EnabledControlFilter = [
+    3,
+    n0,
+    _ECF,
+    0,
+    [_cIo, _st, _dSr, _pIa, _iDS, _rDS],
+    [64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0],
+];
+var EnabledControlInheritanceDrift = [3, n0, _ECID, 0, [_s], [0]];
+var EnabledControlParameter = [3, n0, _ECP, 0, [_k, _va], [0, 15]];
+var EnabledControlParameterSummary = [3, n0, _ECPS, 0, [_k, _va], [0, 15]];
+var EnabledControlResourceDrift = [3, n0, _ECRD, 0, [_s], [0]];
+var EnabledControlSummary = [
+    3,
+    n0,
+    _ECS,
+    0,
+    [_a, _cI, _tI, _sS, _dSS, _pI],
+    [0, 0, 0, () => EnablementStatusSummary, () => DriftStatusSummary, 0],
+];
+var EnablementStatusSummary = [3, n0, _ESS, 0, [_s, _lOI], [0, 0]];
+var GetBaselineInput = [3, n0, _GBI, 0, [_bI], [0]];
+var GetBaselineOperationInput = [3, n0, _GBOI, 0, [_oI], [0]];
+var GetBaselineOperationOutput = [3, n0, _GBOO, 0, [_bO], [() => BaselineOperation]];
+var GetBaselineOutput = [3, n0, _GBO, 0, [_a, _n, _d], [0, 0, 0]];
+var GetControlOperationInput = [3, n0, _GCOI, 0, [_oI], [0]];
+var GetControlOperationOutput = [3, n0, _GCOO, 0, [_cO], [() => ControlOperation]];
+var GetEnabledBaselineInput = [3, n0, _GEBI, 0, [_eBI], [0]];
+var GetEnabledBaselineOutput = [3, n0, _GEBO, 0, [_eBD], [() => EnabledBaselineDetails]];
+var GetEnabledControlInput = [3, n0, _GECI, 0, [_eCI], [0]];
+var GetEnabledControlOutput = [3, n0, _GECO, 0, [_eCD], [() => EnabledControlDetails]];
+var GetLandingZoneInput = [3, n0, _GLZI, 0, [_lZI], [0]];
+var GetLandingZoneOperationInput = [3, n0, _GLZOI, 0, [_oI], [0]];
+var GetLandingZoneOperationOutput = [
+    3,
+    n0,
+    _GLZOO,
+    0,
+    [_oD],
+    [() => LandingZoneOperationDetail],
+];
+var GetLandingZoneOutput = [3, n0, _GLZO, 0, [_lZ], [() => LandingZoneDetail]];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var LandingZoneDetail = [
+    3,
+    n0,
+    _LZD,
+    0,
+    [_v, _ma, _rT, _a, _s, _lAV, _dS],
+    [0, 15, 64 | 0, 0, 0, 0, () => LandingZoneDriftStatusSummary],
+];
+var LandingZoneDriftStatusSummary = [3, n0, _LZDSS, 0, [_s], [0]];
+var LandingZoneOperationDetail = [
+    3,
+    n0,
+    _LZOD,
+    0,
+    [_oT, _oI, _s, _sT, _eT, _sM],
+    [0, 0, 0, 5, 5, 0],
+];
+var LandingZoneOperationFilter = [3, n0, _LZOF, 0, [_ty, _st], [64 | 0, 64 | 0]];
+var LandingZoneOperationSummary = [3, n0, _LZOS, 0, [_oT, _oI, _s], [0, 0, 0]];
+var LandingZoneSummary = [3, n0, _LZS, 0, [_a], [0]];
+var ListBaselinesInput = [3, n0, _LBI, 0, [_nT, _mR], [0, 1]];
+var ListBaselinesOutput = [3, n0, _LBO, 0, [_b, _nT], [() => Baselines, 0]];
+var ListControlOperationsInput = [
+    3,
+    n0,
+    _LCOI,
+    0,
+    [_f, _nT, _mR],
+    [() => ControlOperationFilter, 0, 1],
+];
+var ListControlOperationsOutput = [
+    3,
+    n0,
+    _LCOO,
+    0,
+    [_cOo, _nT],
+    [() => ControlOperations, 0],
+];
+var ListEnabledBaselinesInput = [
+    3,
+    n0,
+    _LEBI,
+    0,
+    [_f, _nT, _mR, _iC],
+    [() => EnabledBaselineFilter, 0, 1, 2],
+];
+var ListEnabledBaselinesOutput = [
+    3,
+    n0,
+    _LEBO,
+    0,
+    [_eB, _nT],
+    [() => EnabledBaselines, 0],
+];
+var ListEnabledControlsInput = [
+    3,
+    n0,
+    _LECI,
+    0,
+    [_tI, _nT, _mR, _f, _iC],
+    [0, 0, 1, () => EnabledControlFilter, 2],
+];
+var ListEnabledControlsOutput = [3, n0, _LECO, 0, [_eC, _nT], [() => EnabledControls, 0]];
+var ListLandingZoneOperationsInput = [
+    3,
+    n0,
+    _LLZOI,
+    0,
+    [_f, _nT, _mR],
+    [() => LandingZoneOperationFilter, 0, 1],
+];
+var ListLandingZoneOperationsOutput = [
+    3,
+    n0,
+    _LLZOO,
+    0,
+    [_lZO, _nT],
+    [() => LandingZoneOperations, 0],
+];
+var ListLandingZonesInput = [3, n0, _LLZI, 0, [_nT, _mR], [0, 1]];
+var ListLandingZonesOutput = [
+    3,
+    n0,
+    _LLZO,
+    0,
+    [_lZa, _nT],
+    [() => LandingZoneSummaries, 0],
+];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_rA], [[0, 1]]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_t], [128 | 0]];
+var Region = [3, n0, _R, 0, [_n], [0]];
+var ResetEnabledBaselineInput = [3, n0, _REBI, 0, [_eBI], [0]];
+var ResetEnabledBaselineOutput = [3, n0, _REBO, 0, [_oI], [0]];
+var ResetEnabledControlInput = [3, n0, _RECI, 0, [_eCI], [0]];
+var ResetEnabledControlOutput = [3, n0, _RECO, 0, [_oI], [0]];
+var ResetLandingZoneInput = [3, n0, _RLZI, 0, [_lZI], [0]];
+var ResetLandingZoneOutput = [3, n0, _RLZO, 0, [_oI], [0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var TagResourceInput = [3, n0, _TRI, 0, [_rA, _t], [[0, 1], 128 | 0]];
+var TagResourceOutput = [3, n0, _TRO, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m, _sC, _qC, _rAS],
+    [
+        0,
+        0,
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceInput = [
+    3,
+    n0,
+    _URI,
+    0,
+    [_rA, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceOutput = [3, n0, _URO, 0, [], []];
+var UpdateEnabledBaselineInput = [
+    3,
+    n0,
+    _UEBI,
+    0,
+    [_bV, _p, _eBI],
+    [0, () => EnabledBaselineParameters, 0],
+];
+var UpdateEnabledBaselineOutput = [3, n0, _UEBO, 0, [_oI], [0]];
+var UpdateEnabledControlInput = [
+    3,
+    n0,
+    _UECI,
+    0,
+    [_p, _eCI],
+    [() => EnabledControlParameters, 0],
+];
+var UpdateEnabledControlOutput = [3, n0, _UECO, 0, [_oI], [0]];
+var UpdateLandingZoneInput = [3, n0, _ULZI, 0, [_v, _ma, _rT, _lZI], [0, 15, 64 | 0, 0]];
+var UpdateLandingZoneOutput = [3, n0, _ULZO, 0, [_oI], [0]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ControlTowerServiceException = [-3, _sm, "ControlTowerServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(ControlTowerServiceException, ControlTowerServiceException$1);
+var Baselines = [1, n0, _B, 0, () => BaselineSummary];
+var ControlOperations = [1, n0, _COo, 0, () => ControlOperationSummary];
+var EnabledBaselineParameters = [1, n0, _EBPn, 0, () => EnabledBaselineParameter];
+var EnabledBaselineParameterSummaries = [
+    1,
+    n0,
+    _EBPSn,
+    0,
+    () => EnabledBaselineParameterSummary,
+];
+var EnabledBaselines = [1, n0, _EB, 0, () => EnabledBaselineSummary];
+var EnabledControlParameters = [1, n0, _ECPn, 0, () => EnabledControlParameter];
+var EnabledControlParameterSummaries = [
+    1,
+    n0,
+    _ECPSn,
+    0,
+    () => EnabledControlParameterSummary,
+];
+var EnabledControls = [1, n0, _EC, 0, () => EnabledControlSummary];
+var LandingZoneOperations = [1, n0, _LZO, 0, () => LandingZoneOperationSummary];
+var LandingZoneSummaries = [1, n0, _LZSa, 0, () => LandingZoneSummary];
+var TargetRegions = [1, n0, _TR, 0, () => Region];
+var CreateLandingZone = [
+    9,
+    n0,
+    _CLZ,
+    {
+        [_h]: ["POST", "/create-landingzone", 200],
+    },
+    () => CreateLandingZoneInput,
+    () => CreateLandingZoneOutput,
+];
+var DeleteLandingZone = [
+    9,
+    n0,
+    _DLZ,
+    {
+        [_h]: ["POST", "/delete-landingzone", 200],
+    },
+    () => DeleteLandingZoneInput,
+    () => DeleteLandingZoneOutput,
+];
+var DisableBaseline = [
+    9,
+    n0,
+    _DB,
+    {
+        [_h]: ["POST", "/disable-baseline", 200],
+    },
+    () => DisableBaselineInput,
+    () => DisableBaselineOutput,
+];
+var DisableControl = [
+    9,
+    n0,
+    _DC,
+    {
+        [_h]: ["POST", "/disable-control", 200],
+    },
+    () => DisableControlInput,
+    () => DisableControlOutput,
+];
+var EnableBaseline = [
+    9,
+    n0,
+    _EBn,
+    {
+        [_h]: ["POST", "/enable-baseline", 200],
+    },
+    () => EnableBaselineInput,
+    () => EnableBaselineOutput,
+];
+var EnableControl = [
+    9,
+    n0,
+    _ECn,
+    {
+        [_h]: ["POST", "/enable-control", 200],
+    },
+    () => EnableControlInput,
+    () => EnableControlOutput,
+];
+var GetBaseline = [
+    9,
+    n0,
+    _GB,
+    {
+        [_h]: ["POST", "/get-baseline", 200],
+    },
+    () => GetBaselineInput,
+    () => GetBaselineOutput,
+];
+var GetBaselineOperation = [
+    9,
+    n0,
+    _GBOe,
+    {
+        [_h]: ["POST", "/get-baseline-operation", 200],
+    },
+    () => GetBaselineOperationInput,
+    () => GetBaselineOperationOutput,
+];
+var GetControlOperation = [
+    9,
+    n0,
+    _GCO,
+    {
+        [_h]: ["POST", "/get-control-operation", 200],
+    },
+    () => GetControlOperationInput,
+    () => GetControlOperationOutput,
+];
+var GetEnabledBaseline = [
+    9,
+    n0,
+    _GEB,
+    {
+        [_h]: ["POST", "/get-enabled-baseline", 200],
+    },
+    () => GetEnabledBaselineInput,
+    () => GetEnabledBaselineOutput,
+];
+var GetEnabledControl = [
+    9,
+    n0,
+    _GEC,
+    {
+        [_h]: ["POST", "/get-enabled-control", 200],
+    },
+    () => GetEnabledControlInput,
+    () => GetEnabledControlOutput,
+];
+var GetLandingZone = [
+    9,
+    n0,
+    _GLZ,
+    {
+        [_h]: ["POST", "/get-landingzone", 200],
+    },
+    () => GetLandingZoneInput,
+    () => GetLandingZoneOutput,
+];
+var GetLandingZoneOperation = [
+    9,
+    n0,
+    _GLZOe,
+    {
+        [_h]: ["POST", "/get-landingzone-operation", 200],
+    },
+    () => GetLandingZoneOperationInput,
+    () => GetLandingZoneOperationOutput,
+];
+var ListBaselines = [
+    9,
+    n0,
+    _LB,
+    {
+        [_h]: ["POST", "/list-baselines", 200],
+    },
+    () => ListBaselinesInput,
+    () => ListBaselinesOutput,
+];
+var ListControlOperations = [
+    9,
+    n0,
+    _LCO,
+    {
+        [_h]: ["POST", "/list-control-operations", 200],
+    },
+    () => ListControlOperationsInput,
+    () => ListControlOperationsOutput,
+];
+var ListEnabledBaselines = [
+    9,
+    n0,
+    _LEB,
+    {
+        [_h]: ["POST", "/list-enabled-baselines", 200],
+    },
+    () => ListEnabledBaselinesInput,
+    () => ListEnabledBaselinesOutput,
+];
+var ListEnabledControls = [
+    9,
+    n0,
+    _LEC,
+    {
+        [_h]: ["POST", "/list-enabled-controls", 200],
+    },
+    () => ListEnabledControlsInput,
+    () => ListEnabledControlsOutput,
+];
+var ListLandingZoneOperations = [
+    9,
+    n0,
+    _LLZOi,
+    {
+        [_h]: ["POST", "/list-landingzone-operations", 200],
+    },
+    () => ListLandingZoneOperationsInput,
+    () => ListLandingZoneOperationsOutput,
+];
+var ListLandingZones = [
+    9,
+    n0,
+    _LLZ,
+    {
+        [_h]: ["POST", "/list-landingzones", 200],
+    },
+    () => ListLandingZonesInput,
+    () => ListLandingZonesOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var ResetEnabledBaseline = [
+    9,
+    n0,
+    _REB,
+    {
+        [_h]: ["POST", "/reset-enabled-baseline", 200],
+    },
+    () => ResetEnabledBaselineInput,
+    () => ResetEnabledBaselineOutput,
+];
+var ResetEnabledControl = [
+    9,
+    n0,
+    _REC,
+    {
+        [_h]: ["POST", "/reset-enabled-control", 200],
+    },
+    () => ResetEnabledControlInput,
+    () => ResetEnabledControlOutput,
+];
+var ResetLandingZone = [
+    9,
+    n0,
+    _RLZ,
+    {
+        [_h]: ["POST", "/reset-landingzone", 200],
+    },
+    () => ResetLandingZoneInput,
+    () => ResetLandingZoneOutput,
+];
+var TagResource = [
+    9,
+    n0,
+    _TRa,
+    {
+        [_h]: ["POST", "/tags/{resourceArn}", 204],
+    },
+    () => TagResourceInput,
+    () => TagResourceOutput,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{resourceArn}", 204],
+    },
+    () => UntagResourceInput,
+    () => UntagResourceOutput,
+];
+var UpdateEnabledBaseline = [
+    9,
+    n0,
+    _UEB,
+    {
+        [_h]: ["POST", "/update-enabled-baseline", 200],
+    },
+    () => UpdateEnabledBaselineInput,
+    () => UpdateEnabledBaselineOutput,
+];
+var UpdateEnabledControl = [
+    9,
+    n0,
+    _UEC,
+    {
+        [_h]: ["POST", "/update-enabled-control", 200],
+    },
+    () => UpdateEnabledControlInput,
+    () => UpdateEnabledControlOutput,
+];
+var UpdateLandingZone = [
+    9,
+    n0,
+    _ULZ,
+    {
+        [_h]: ["POST", "/update-landingzone", 200],
+    },
+    () => UpdateLandingZoneInput,
+    () => UpdateLandingZoneOutput,
+];
 
 class CreateLandingZoneCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "CreateLandingZone", {})
     .n("ControlTowerClient", "CreateLandingZoneCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateLandingZoneCommand)
-    .de(de_CreateLandingZoneCommand)
+    .sc(CreateLandingZone)
     .build() {
 }
 
@@ -1383,16 +1224,11 @@ class DeleteLandingZoneCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "DeleteLandingZone", {})
     .n("ControlTowerClient", "DeleteLandingZoneCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteLandingZoneCommand)
-    .de(de_DeleteLandingZoneCommand)
+    .sc(DeleteLandingZone)
     .build() {
 }
 
@@ -1400,16 +1236,11 @@ class DisableBaselineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "DisableBaseline", {})
     .n("ControlTowerClient", "DisableBaselineCommand")
-    .f(void 0, void 0)
-    .ser(se_DisableBaselineCommand)
-    .de(de_DisableBaselineCommand)
+    .sc(DisableBaseline)
     .build() {
 }
 
@@ -1417,16 +1248,11 @@ class DisableControlCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "DisableControl", {})
     .n("ControlTowerClient", "DisableControlCommand")
-    .f(void 0, void 0)
-    .ser(se_DisableControlCommand)
-    .de(de_DisableControlCommand)
+    .sc(DisableControl)
     .build() {
 }
 
@@ -1434,16 +1260,11 @@ class EnableBaselineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "EnableBaseline", {})
     .n("ControlTowerClient", "EnableBaselineCommand")
-    .f(void 0, void 0)
-    .ser(se_EnableBaselineCommand)
-    .de(de_EnableBaselineCommand)
+    .sc(EnableBaseline)
     .build() {
 }
 
@@ -1451,16 +1272,11 @@ class EnableControlCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "EnableControl", {})
     .n("ControlTowerClient", "EnableControlCommand")
-    .f(void 0, void 0)
-    .ser(se_EnableControlCommand)
-    .de(de_EnableControlCommand)
+    .sc(EnableControl)
     .build() {
 }
 
@@ -1468,16 +1284,11 @@ class GetBaselineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "GetBaseline", {})
     .n("ControlTowerClient", "GetBaselineCommand")
-    .f(void 0, void 0)
-    .ser(se_GetBaselineCommand)
-    .de(de_GetBaselineCommand)
+    .sc(GetBaseline)
     .build() {
 }
 
@@ -1485,16 +1296,11 @@ class GetBaselineOperationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "GetBaselineOperation", {})
     .n("ControlTowerClient", "GetBaselineOperationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetBaselineOperationCommand)
-    .de(de_GetBaselineOperationCommand)
+    .sc(GetBaselineOperation)
     .build() {
 }
 
@@ -1502,16 +1308,11 @@ class GetControlOperationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "GetControlOperation", {})
     .n("ControlTowerClient", "GetControlOperationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetControlOperationCommand)
-    .de(de_GetControlOperationCommand)
+    .sc(GetControlOperation)
     .build() {
 }
 
@@ -1519,16 +1320,11 @@ class GetEnabledBaselineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "GetEnabledBaseline", {})
     .n("ControlTowerClient", "GetEnabledBaselineCommand")
-    .f(void 0, void 0)
-    .ser(se_GetEnabledBaselineCommand)
-    .de(de_GetEnabledBaselineCommand)
+    .sc(GetEnabledBaseline)
     .build() {
 }
 
@@ -1536,16 +1332,11 @@ class GetEnabledControlCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "GetEnabledControl", {})
     .n("ControlTowerClient", "GetEnabledControlCommand")
-    .f(void 0, void 0)
-    .ser(se_GetEnabledControlCommand)
-    .de(de_GetEnabledControlCommand)
+    .sc(GetEnabledControl)
     .build() {
 }
 
@@ -1553,16 +1344,11 @@ class GetLandingZoneCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "GetLandingZone", {})
     .n("ControlTowerClient", "GetLandingZoneCommand")
-    .f(void 0, void 0)
-    .ser(se_GetLandingZoneCommand)
-    .de(de_GetLandingZoneCommand)
+    .sc(GetLandingZone)
     .build() {
 }
 
@@ -1570,16 +1356,11 @@ class GetLandingZoneOperationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "GetLandingZoneOperation", {})
     .n("ControlTowerClient", "GetLandingZoneOperationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetLandingZoneOperationCommand)
-    .de(de_GetLandingZoneOperationCommand)
+    .sc(GetLandingZoneOperation)
     .build() {
 }
 
@@ -1587,16 +1368,11 @@ class ListBaselinesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ListBaselines", {})
     .n("ControlTowerClient", "ListBaselinesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListBaselinesCommand)
-    .de(de_ListBaselinesCommand)
+    .sc(ListBaselines)
     .build() {
 }
 
@@ -1604,16 +1380,11 @@ class ListControlOperationsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ListControlOperations", {})
     .n("ControlTowerClient", "ListControlOperationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListControlOperationsCommand)
-    .de(de_ListControlOperationsCommand)
+    .sc(ListControlOperations)
     .build() {
 }
 
@@ -1621,16 +1392,11 @@ class ListEnabledBaselinesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ListEnabledBaselines", {})
     .n("ControlTowerClient", "ListEnabledBaselinesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListEnabledBaselinesCommand)
-    .de(de_ListEnabledBaselinesCommand)
+    .sc(ListEnabledBaselines)
     .build() {
 }
 
@@ -1638,16 +1404,11 @@ class ListEnabledControlsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ListEnabledControls", {})
     .n("ControlTowerClient", "ListEnabledControlsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListEnabledControlsCommand)
-    .de(de_ListEnabledControlsCommand)
+    .sc(ListEnabledControls)
     .build() {
 }
 
@@ -1655,16 +1416,11 @@ class ListLandingZoneOperationsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ListLandingZoneOperations", {})
     .n("ControlTowerClient", "ListLandingZoneOperationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListLandingZoneOperationsCommand)
-    .de(de_ListLandingZoneOperationsCommand)
+    .sc(ListLandingZoneOperations)
     .build() {
 }
 
@@ -1672,16 +1428,11 @@ class ListLandingZonesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ListLandingZones", {})
     .n("ControlTowerClient", "ListLandingZonesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListLandingZonesCommand)
-    .de(de_ListLandingZonesCommand)
+    .sc(ListLandingZones)
     .build() {
 }
 
@@ -1689,16 +1440,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ListTagsForResource", {})
     .n("ControlTowerClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1706,16 +1452,11 @@ class ResetEnabledBaselineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ResetEnabledBaseline", {})
     .n("ControlTowerClient", "ResetEnabledBaselineCommand")
-    .f(void 0, void 0)
-    .ser(se_ResetEnabledBaselineCommand)
-    .de(de_ResetEnabledBaselineCommand)
+    .sc(ResetEnabledBaseline)
     .build() {
 }
 
@@ -1723,16 +1464,11 @@ class ResetEnabledControlCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ResetEnabledControl", {})
     .n("ControlTowerClient", "ResetEnabledControlCommand")
-    .f(void 0, void 0)
-    .ser(se_ResetEnabledControlCommand)
-    .de(de_ResetEnabledControlCommand)
+    .sc(ResetEnabledControl)
     .build() {
 }
 
@@ -1740,16 +1476,11 @@ class ResetLandingZoneCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "ResetLandingZone", {})
     .n("ControlTowerClient", "ResetLandingZoneCommand")
-    .f(void 0, void 0)
-    .ser(se_ResetLandingZoneCommand)
-    .de(de_ResetLandingZoneCommand)
+    .sc(ResetLandingZone)
     .build() {
 }
 
@@ -1757,16 +1488,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "TagResource", {})
     .n("ControlTowerClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1774,16 +1500,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "UntagResource", {})
     .n("ControlTowerClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1791,16 +1512,11 @@ class UpdateEnabledBaselineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "UpdateEnabledBaseline", {})
     .n("ControlTowerClient", "UpdateEnabledBaselineCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateEnabledBaselineCommand)
-    .de(de_UpdateEnabledBaselineCommand)
+    .sc(UpdateEnabledBaseline)
     .build() {
 }
 
@@ -1808,16 +1524,11 @@ class UpdateEnabledControlCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "UpdateEnabledControl", {})
     .n("ControlTowerClient", "UpdateEnabledControlCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateEnabledControlCommand)
-    .de(de_UpdateEnabledControlCommand)
+    .sc(UpdateEnabledControl)
     .build() {
 }
 
@@ -1825,16 +1536,11 @@ class UpdateLandingZoneCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSControlTowerApis", "UpdateLandingZone", {})
     .n("ControlTowerClient", "UpdateLandingZoneCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateLandingZoneCommand)
-    .de(de_UpdateLandingZoneCommand)
+    .sc(UpdateLandingZone)
     .build() {
 }
 
@@ -1892,15 +1598,15 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.BaselineOperationStatus = BaselineOperationStatus;
 exports.BaselineOperationType = BaselineOperationType;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.ControlOperationStatus = ControlOperationStatus;
 exports.ControlOperationType = ControlOperationType;
 exports.ControlTower = ControlTower;
 exports.ControlTowerClient = ControlTowerClient;
-exports.ControlTowerServiceException = ControlTowerServiceException;
+exports.ControlTowerServiceException = ControlTowerServiceException$1;
 exports.CreateLandingZoneCommand = CreateLandingZoneCommand;
 exports.DeleteLandingZoneCommand = DeleteLandingZoneCommand;
 exports.DisableBaselineCommand = DisableBaselineCommand;
@@ -1917,7 +1623,7 @@ exports.GetEnabledBaselineCommand = GetEnabledBaselineCommand;
 exports.GetEnabledControlCommand = GetEnabledControlCommand;
 exports.GetLandingZoneCommand = GetLandingZoneCommand;
 exports.GetLandingZoneOperationCommand = GetLandingZoneOperationCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.LandingZoneDriftStatus = LandingZoneDriftStatus;
 exports.LandingZoneOperationStatus = LandingZoneOperationStatus;
 exports.LandingZoneOperationType = LandingZoneOperationType;
@@ -1933,15 +1639,15 @@ exports.RemediationType = RemediationType;
 exports.ResetEnabledBaselineCommand = ResetEnabledBaselineCommand;
 exports.ResetEnabledControlCommand = ResetEnabledControlCommand;
 exports.ResetLandingZoneCommand = ResetLandingZoneCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateEnabledBaselineCommand = UpdateEnabledBaselineCommand;
 exports.UpdateEnabledControlCommand = UpdateEnabledControlCommand;
 exports.UpdateLandingZoneCommand = UpdateLandingZoneCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListBaselines = paginateListBaselines;
 exports.paginateListControlOperations = paginateListControlOperations;
 exports.paginateListEnabledBaselines = paginateListEnabledBaselines;