@aws-sdk/client-observabilityadmin 3.928.0 → 3.930.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 ObservabilityAdminClient 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 ObservabilityAdminClient extends smithyClient.Client {
     }
 }
 
-class ObservabilityAdminServiceException extends smithyClient.ServiceException {
+let ObservabilityAdminServiceException$1 = class ObservabilityAdminServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, ObservabilityAdminServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends ObservabilityAdminServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends ObservabilityAdminServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -132,7 +132,7 @@ class AccessDeniedException extends ObservabilityAdminServiceException {
         this.Message = opts.Message;
         this.amznErrorType = opts.amznErrorType;
     }
-}
+};
 const CentralizationFailureReason = {
     DESTINATION_ACCOUNT_NOT_IN_ORGANIZATION: "DESTINATION_ACCOUNT_NOT_IN_ORGANIZATION",
     INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
@@ -155,7 +155,7 @@ const RuleHealth = {
     PROVISIONING: "Provisioning",
     UNHEALTHY: "Unhealthy",
 };
-class ConflictException extends ObservabilityAdminServiceException {
+let ConflictException$1 = class ConflictException extends ObservabilityAdminServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -168,8 +168,8 @@ class ConflictException extends ObservabilityAdminServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.Message = opts.Message;
     }
-}
-class InternalServerException extends ObservabilityAdminServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends ObservabilityAdminServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     Message;
@@ -184,8 +184,8 @@ class InternalServerException extends ObservabilityAdminServiceException {
         this.Message = opts.Message;
         this.amznErrorType = opts.amznErrorType;
     }
-}
-class ServiceQuotaExceededException extends ObservabilityAdminServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends ObservabilityAdminServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -200,8 +200,8 @@ class ServiceQuotaExceededException extends ObservabilityAdminServiceException {
         this.Message = opts.Message;
         this.amznErrorType = opts.amznErrorType;
     }
-}
-class TooManyRequestsException extends ObservabilityAdminServiceException {
+};
+let TooManyRequestsException$1 = class TooManyRequestsException extends ObservabilityAdminServiceException$1 {
     name = "TooManyRequestsException";
     $fault = "client";
     Message;
@@ -214,8 +214,8 @@ class TooManyRequestsException extends ObservabilityAdminServiceException {
         Object.setPrototypeOf(this, TooManyRequestsException.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationException extends ObservabilityAdminServiceException {
+};
+let ValidationException$1 = class ValidationException extends ObservabilityAdminServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -228,7 +228,7 @@ class ValidationException extends ObservabilityAdminServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const DestinationType = {
     CLOUDWATCH_LOGS: "cloud-watch-logs",
 };
@@ -242,7 +242,7 @@ const TelemetryType = {
     METRICS: "Metrics",
     TRACES: "Traces",
 };
-class ResourceNotFoundException extends ObservabilityAdminServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends ObservabilityAdminServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -255,7 +255,7 @@ class ResourceNotFoundException extends ObservabilityAdminServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const TelemetryEnrichmentStatus = {
     IMPAIRED: "Impaired",
     RUNNING: "Running",
@@ -276,922 +276,824 @@ const TelemetryState = {
     NOT_APPLICABLE: "NotApplicable",
 };
 
-const se_CreateCentralizationRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateCentralizationRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Rule: (_) => smithyClient._json(_),
-        RuleName: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateTelemetryRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateTelemetryRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Rule: (_) => smithyClient._json(_),
-        RuleName: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateTelemetryRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateTelemetryRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Rule: (_) => smithyClient._json(_),
-        RuleName: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteCentralizationRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteCentralizationRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteTelemetryRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteTelemetryRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteTelemetryRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteTelemetryRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetCentralizationRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetCentralizationRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTelemetryEnrichmentStatusCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/GetTelemetryEnrichmentStatus");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTelemetryEvaluationStatusCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/GetTelemetryEvaluationStatus");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTelemetryEvaluationStatusForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/GetTelemetryEvaluationStatusForOrganization");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTelemetryRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetTelemetryRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTelemetryRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetTelemetryRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListCentralizationRulesForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListCentralizationRulesForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AllRegions: [],
-        MaxResults: [],
-        NextToken: [],
-        RuleNamePrefix: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListResourceTelemetryCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListResourceTelemetry");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        ResourceIdentifierPrefix: [],
-        ResourceTags: (_) => smithyClient._json(_),
-        ResourceTypes: (_) => smithyClient._json(_),
-        TelemetryConfigurationState: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListResourceTelemetryForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListResourceTelemetryForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        AccountIdentifiers: (_) => smithyClient._json(_),
-        MaxResults: [],
-        NextToken: [],
-        ResourceIdentifierPrefix: [],
-        ResourceTags: (_) => smithyClient._json(_),
-        ResourceTypes: (_) => smithyClient._json(_),
-        TelemetryConfigurationState: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ResourceARN: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTelemetryRulesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListTelemetryRules");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        RuleNamePrefix: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTelemetryRulesForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListTelemetryRulesForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        RuleNamePrefix: [],
-        SourceAccountIds: (_) => smithyClient._json(_),
-        SourceOrganizationUnitIds: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartTelemetryEnrichmentCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/StartTelemetryEnrichment");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartTelemetryEvaluationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/StartTelemetryEvaluation");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartTelemetryEvaluationForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/StartTelemetryEvaluationForOrganization");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopTelemetryEnrichmentCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/StopTelemetryEnrichment");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopTelemetryEvaluationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/StopTelemetryEvaluation");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopTelemetryEvaluationForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/StopTelemetryEvaluationForOrganization");
-    let body;
-    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("/TagResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ResourceARN: [],
-        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 = {
-        "content-type": "application/json",
-    };
-    b.bp("/UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ResourceARN: [],
-        TagKeys: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateCentralizationRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateCentralizationRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Rule: (_) => smithyClient._json(_),
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateTelemetryRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateTelemetryRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Rule: (_) => smithyClient._json(_),
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateTelemetryRuleForOrganizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateTelemetryRuleForOrganization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Rule: (_) => smithyClient._json(_),
-        RuleIdentifier: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CreateCentralizationRuleForOrganizationCommand = 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, {
-        RuleArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateTelemetryRuleCommand = 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, {
-        RuleArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateTelemetryRuleForOrganizationCommand = 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, {
-        RuleArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteCentralizationRuleForOrganizationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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_DeleteTelemetryRuleCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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_DeleteTelemetryRuleForOrganizationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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_GetCentralizationRuleForOrganizationCommand = 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, {
-        CentralizationRule: smithyClient._json,
-        CreatedRegion: smithyClient.expectString,
-        CreatedTimeStamp: smithyClient.expectLong,
-        CreatorAccountId: smithyClient.expectString,
-        FailureReason: smithyClient.expectString,
-        LastUpdateTimeStamp: smithyClient.expectLong,
-        RuleArn: smithyClient.expectString,
-        RuleHealth: smithyClient.expectString,
-        RuleName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTelemetryEnrichmentStatusCommand = 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, {
-        AwsResourceExplorerManagedViewArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTelemetryEvaluationStatusCommand = 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, {
-        FailureReason: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTelemetryEvaluationStatusForOrganizationCommand = 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, {
-        FailureReason: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTelemetryRuleCommand = 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, {
-        CreatedTimeStamp: smithyClient.expectLong,
-        LastUpdateTimeStamp: smithyClient.expectLong,
-        RuleArn: smithyClient.expectString,
-        RuleName: smithyClient.expectString,
-        TelemetryRule: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTelemetryRuleForOrganizationCommand = 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, {
-        CreatedTimeStamp: smithyClient.expectLong,
-        LastUpdateTimeStamp: smithyClient.expectLong,
-        RuleArn: smithyClient.expectString,
-        RuleName: smithyClient.expectString,
-        TelemetryRule: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListCentralizationRulesForOrganizationCommand = 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, {
-        CentralizationRuleSummaries: smithyClient._json,
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListResourceTelemetryCommand = 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, {
-        NextToken: smithyClient.expectString,
-        TelemetryConfigurations: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListResourceTelemetryForOrganizationCommand = 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, {
-        NextToken: smithyClient.expectString,
-        TelemetryConfigurations: smithyClient._json,
-    });
-    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_ListTelemetryRulesCommand = 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, {
-        NextToken: smithyClient.expectString,
-        TelemetryRuleSummaries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTelemetryRulesForOrganizationCommand = 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, {
-        NextToken: smithyClient.expectString,
-        TelemetryRuleSummaries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartTelemetryEnrichmentCommand = async (output, context) => {
-    if (output.statusCode !== 202 && 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, {
-        AwsResourceExplorerManagedViewArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartTelemetryEvaluationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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_StartTelemetryEvaluationForOrganizationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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_StopTelemetryEnrichmentCommand = async (output, context) => {
-    if (output.statusCode !== 202 && 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, {
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StopTelemetryEvaluationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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_StopTelemetryEvaluationForOrganizationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && 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 !== 200 && 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_UpdateCentralizationRuleForOrganizationCommand = 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, {
-        RuleArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateTelemetryRuleCommand = 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, {
-        RuleArn: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateTelemetryRuleForOrganizationCommand = 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, {
-        RuleArn: 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.observabilityadmin#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.observabilityadmin#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.observabilityadmin#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.observabilityadmin#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "TooManyRequestsException":
-        case "com.amazonaws.observabilityadmin#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.observabilityadmin#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.observabilityadmin#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(ObservabilityAdminServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_aET]: [, parsedOutput.headers[_xae]],
-    });
-    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({
-        [_aET]: [, parsedOutput.headers[_xae]],
-    });
-    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({
-        [_aET]: [, parsedOutput.headers[_xae]],
-    });
-    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_TooManyRequestsExceptionRes = 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 TooManyRequestsException({
-        $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 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 _A = "Account";
+const _ADE = "AccessDeniedException";
+const _AI = "AccountIdentifiers";
+const _AIc = "AccountIdentifier";
+const _AR = "AllRegions";
+const _AREMVA = "AwsResourceExplorerManagedViewArn";
+const _BC = "BackupConfiguration";
+const _CAI = "CreatorAccountId";
+const _CCRFO = "CreateCentralizationRuleForOrganization";
+const _CCRFOI = "CreateCentralizationRuleForOrganizationInput";
+const _CCRFOO = "CreateCentralizationRuleForOrganizationOutput";
+const _CE = "ConflictException";
+const _CR = "CentralizationRule";
+const _CRD = "CentralizationRuleDestination";
+const _CRS = "CentralizationRuleSource";
+const _CRSe = "CentralizationRuleSummary";
+const _CRSen = "CentralizationRuleSummaries";
+const _CRr = "CreatedRegion";
+const _CTR = "CreateTelemetryRule";
+const _CTRFO = "CreateTelemetryRuleForOrganization";
+const _CTRFOI = "CreateTelemetryRuleForOrganizationInput";
+const _CTRFOO = "CreateTelemetryRuleForOrganizationOutput";
+const _CTRI = "CreateTelemetryRuleInput";
+const _CTRO = "CreateTelemetryRuleOutput";
+const _CTS = "CreatedTimeStamp";
+const _D = "Destination";
+const _DAI = "DestinationAccountId";
+const _DC = "DestinationConfiguration";
+const _DCRFO = "DeleteCentralizationRuleForOrganization";
+const _DCRFOI = "DeleteCentralizationRuleForOrganizationInput";
+const _DLC = "DestinationLogsConfiguration";
+const _DP = "DestinationPattern";
+const _DR = "DestinationRegion";
+const _DT = "DestinationType";
+const _DTR = "DeleteTelemetryRule";
+const _DTRFO = "DeleteTelemetryRuleForOrganization";
+const _DTRFOI = "DeleteTelemetryRuleForOrganizationInput";
+const _DTRI = "DeleteTelemetryRuleInput";
+const _ECRS = "EncryptionConflictResolutionStrategy";
+const _ELGS = "EncryptedLogGroupStrategy";
+const _ES = "EncryptionStrategy";
+const _FR = "FailureReason";
+const _GCRFO = "GetCentralizationRuleForOrganization";
+const _GCRFOI = "GetCentralizationRuleForOrganizationInput";
+const _GCRFOO = "GetCentralizationRuleForOrganizationOutput";
+const _GTES = "GetTelemetryEnrichmentStatus";
+const _GTESFO = "GetTelemetryEvaluationStatusForOrganization";
+const _GTESFOO = "GetTelemetryEvaluationStatusForOrganizationOutput";
+const _GTESO = "GetTelemetryEnrichmentStatusOutput";
+const _GTESOe = "GetTelemetryEvaluationStatusOutput";
+const _GTESe = "GetTelemetryEvaluationStatus";
+const _GTR = "GetTelemetryRule";
+const _GTRFO = "GetTelemetryRuleForOrganization";
+const _GTRFOI = "GetTelemetryRuleForOrganizationInput";
+const _GTRFOO = "GetTelemetryRuleForOrganizationOutput";
+const _GTRI = "GetTelemetryRuleInput";
+const _GTRO = "GetTelemetryRuleOutput";
+const _ISE = "InternalServerException";
+const _KKA = "KmsKeyArn";
+const _LBC = "LogsBackupConfiguration";
+const _LCRFO = "ListCentralizationRulesForOrganization";
+const _LCRFOI = "ListCentralizationRulesForOrganizationInput";
+const _LCRFOO = "ListCentralizationRulesForOrganizationOutput";
+const _LEC = "LogsEncryptionConfiguration";
+const _LF = "LogFormat";
+const _LGSC = "LogGroupSelectionCriteria";
+const _LRT = "ListResourceTelemetry";
+const _LRTFO = "ListResourceTelemetryForOrganization";
+const _LRTFOI = "ListResourceTelemetryForOrganizationInput";
+const _LRTFOO = "ListResourceTelemetryForOrganizationOutput";
+const _LRTI = "ListResourceTelemetryInput";
+const _LRTO = "ListResourceTelemetryOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _LTR = "ListTelemetryRules";
+const _LTRFO = "ListTelemetryRulesForOrganization";
+const _LTRFOI = "ListTelemetryRulesForOrganizationInput";
+const _LTRFOO = "ListTelemetryRulesForOrganizationOutput";
+const _LTRI = "ListTelemetryRulesInput";
+const _LTRO = "ListTelemetryRulesOutput";
+const _LUTS = "LastUpdateTimeStamp";
+const _M = "Message";
+const _MAI = "MaxAggregationInterval";
+const _MR = "MaxResults";
+const _NT = "NextToken";
+const _R = "Region";
+const _RA = "RuleArn";
+const _RARN = "ResourceARN";
+const _RH = "RuleHealth";
+const _RI = "RuleIdentifier";
+const _RID = "RetentionInDays";
+const _RIP = "ResourceIdentifierPrefix";
+const _RIe = "ResourceIdentifier";
+const _RN = "RuleName";
+const _RNFE = "ResourceNotFoundException";
+const _RNP = "RuleNamePrefix";
+const _RT = "ResourceTypes";
+const _RTe = "ResourceTags";
+const _RTes = "ResourceType";
+const _Re = "Regions";
+const _Ru = "Rule";
+const _S = "Source";
+const _SAI = "SourceAccountIds";
+const _SC = "SelectionCriteria";
+const _SLC = "SourceLogsConfiguration";
+const _SOUI = "SourceOrganizationUnitIds";
+const _SQEE = "ServiceQuotaExceededException";
+const _STE = "StartTelemetryEnrichment";
+const _STEFO = "StartTelemetryEvaluationForOrganization";
+const _STEFOt = "StopTelemetryEvaluationForOrganization";
+const _STEO = "StartTelemetryEnrichmentOutput";
+const _STEOt = "StopTelemetryEnrichmentOutput";
+const _STEt = "StartTelemetryEvaluation";
+const _STEto = "StopTelemetryEnrichment";
+const _STEtop = "StopTelemetryEvaluation";
+const _Sc = "Scope";
+const _St = "Status";
+const _T = "Tags";
+const _TC = "TelemetryConfigurations";
+const _TCS = "TelemetryConfigurationState";
+const _TCe = "TelemetryConfiguration";
+const _TDC = "TelemetryDestinationConfiguration";
+const _TK = "TagKeys";
+const _TMRE = "TooManyRequestsException";
+const _TR = "TelemetryRule";
+const _TRI = "TagResourceInput";
+const _TRS = "TelemetryRuleSummaries";
+const _TRSe = "TelemetryRuleSummary";
+const _TRa = "TagResource";
+const _TT = "TelemetryType";
+const _TTr = "TrafficType";
+const _UCRFO = "UpdateCentralizationRuleForOrganization";
+const _UCRFOI = "UpdateCentralizationRuleForOrganizationInput";
+const _UCRFOO = "UpdateCentralizationRuleForOrganizationOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _UTR = "UpdateTelemetryRule";
+const _UTRFO = "UpdateTelemetryRuleForOrganization";
+const _UTRFOI = "UpdateTelemetryRuleForOrganizationInput";
+const _UTRFOO = "UpdateTelemetryRuleForOrganizationOutput";
+const _UTRI = "UpdateTelemetryRuleInput";
+const _UTRO = "UpdateTelemetryRuleOutput";
+const _VE = "ValidationException";
+const _VPCFLP = "VPCFlowLogParameters";
 const _aET = "amznErrorType";
-const _xae = "x-amzn-errortype";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.observabilityadmin";
+const _xaE = "x-amzn-ErrorType";
+const n0 = "com.amazonaws.observabilityadmin";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _aET],
+    [
+        0,
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var CentralizationRule = [
+    3,
+    n0,
+    _CR,
+    0,
+    [_S, _D],
+    [() => CentralizationRuleSource, () => CentralizationRuleDestination],
+];
+var CentralizationRuleDestination = [
+    3,
+    n0,
+    _CRD,
+    0,
+    [_R, _A, _DLC],
+    [0, 0, () => DestinationLogsConfiguration],
+];
+var CentralizationRuleSource = [
+    3,
+    n0,
+    _CRS,
+    0,
+    [_Re, _Sc, _SLC],
+    [64 | 0, 0, () => SourceLogsConfiguration],
+];
+var CentralizationRuleSummary = [
+    3,
+    n0,
+    _CRSe,
+    0,
+    [_RN, _RA, _CAI, _CTS, _CRr, _LUTS, _RH, _FR, _DAI, _DR],
+    [0, 0, 0, 1, 0, 1, 0, 0, 0, 0],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateCentralizationRuleForOrganizationInput = [
+    3,
+    n0,
+    _CCRFOI,
+    0,
+    [_RN, _Ru, _T],
+    [0, () => CentralizationRule, 128 | 0],
+];
+var CreateCentralizationRuleForOrganizationOutput = [3, n0, _CCRFOO, 0, [_RA], [0]];
+var CreateTelemetryRuleForOrganizationInput = [
+    3,
+    n0,
+    _CTRFOI,
+    0,
+    [_RN, _Ru, _T],
+    [0, () => TelemetryRule, 128 | 0],
+];
+var CreateTelemetryRuleForOrganizationOutput = [3, n0, _CTRFOO, 0, [_RA], [0]];
+var CreateTelemetryRuleInput = [
+    3,
+    n0,
+    _CTRI,
+    0,
+    [_RN, _Ru, _T],
+    [0, () => TelemetryRule, 128 | 0],
+];
+var CreateTelemetryRuleOutput = [3, n0, _CTRO, 0, [_RA], [0]];
+var DeleteCentralizationRuleForOrganizationInput = [3, n0, _DCRFOI, 0, [_RI], [0]];
+var DeleteTelemetryRuleForOrganizationInput = [3, n0, _DTRFOI, 0, [_RI], [0]];
+var DeleteTelemetryRuleInput = [3, n0, _DTRI, 0, [_RI], [0]];
+var DestinationLogsConfiguration = [
+    3,
+    n0,
+    _DLC,
+    0,
+    [_LEC, _BC],
+    [() => LogsEncryptionConfiguration, () => LogsBackupConfiguration],
+];
+var GetCentralizationRuleForOrganizationInput = [3, n0, _GCRFOI, 0, [_RI], [0]];
+var GetCentralizationRuleForOrganizationOutput = [
+    3,
+    n0,
+    _GCRFOO,
+    0,
+    [_RN, _RA, _CAI, _CTS, _CRr, _LUTS, _RH, _FR, _CR],
+    [0, 0, 0, 1, 0, 1, 0, 0, () => CentralizationRule],
+];
+var GetTelemetryEnrichmentStatusOutput = [3, n0, _GTESO, 0, [_St, _AREMVA], [0, 0]];
+var GetTelemetryEvaluationStatusForOrganizationOutput = [
+    3,
+    n0,
+    _GTESFOO,
+    0,
+    [_St, _FR],
+    [0, 0],
+];
+var GetTelemetryEvaluationStatusOutput = [3, n0, _GTESOe, 0, [_St, _FR], [0, 0]];
+var GetTelemetryRuleForOrganizationInput = [3, n0, _GTRFOI, 0, [_RI], [0]];
+var GetTelemetryRuleForOrganizationOutput = [
+    3,
+    n0,
+    _GTRFOO,
+    0,
+    [_RN, _RA, _CTS, _LUTS, _TR],
+    [0, 0, 1, 1, () => TelemetryRule],
+];
+var GetTelemetryRuleInput = [3, n0, _GTRI, 0, [_RI], [0]];
+var GetTelemetryRuleOutput = [
+    3,
+    n0,
+    _GTRO,
+    0,
+    [_RN, _RA, _CTS, _LUTS, _TR],
+    [0, 0, 1, 1, () => TelemetryRule],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M, _aET],
+    [
+        0,
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListCentralizationRulesForOrganizationInput = [
+    3,
+    n0,
+    _LCRFOI,
+    0,
+    [_RNP, _AR, _MR, _NT],
+    [0, 2, 1, 0],
+];
+var ListCentralizationRulesForOrganizationOutput = [
+    3,
+    n0,
+    _LCRFOO,
+    0,
+    [_CRSen, _NT],
+    [() => CentralizationRuleSummaries, 0],
+];
+var ListResourceTelemetryForOrganizationInput = [
+    3,
+    n0,
+    _LRTFOI,
+    0,
+    [_AI, _RIP, _RT, _TCS, _RTe, _MR, _NT],
+    [64 | 0, 0, 64 | 0, 128 | 0, 128 | 0, 1, 0],
+];
+var ListResourceTelemetryForOrganizationOutput = [
+    3,
+    n0,
+    _LRTFOO,
+    0,
+    [_TC, _NT],
+    [() => TelemetryConfigurations, 0],
+];
+var ListResourceTelemetryInput = [
+    3,
+    n0,
+    _LRTI,
+    0,
+    [_RIP, _RT, _TCS, _RTe, _MR, _NT],
+    [0, 64 | 0, 128 | 0, 128 | 0, 1, 0],
+];
+var ListResourceTelemetryOutput = [
+    3,
+    n0,
+    _LRTO,
+    0,
+    [_TC, _NT],
+    [() => TelemetryConfigurations, 0],
+];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_RARN], [0]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_T], [128 | 0]];
+var ListTelemetryRulesForOrganizationInput = [
+    3,
+    n0,
+    _LTRFOI,
+    0,
+    [_RNP, _SAI, _SOUI, _MR, _NT],
+    [0, 64 | 0, 64 | 0, 1, 0],
+];
+var ListTelemetryRulesForOrganizationOutput = [
+    3,
+    n0,
+    _LTRFOO,
+    0,
+    [_TRS, _NT],
+    [() => TelemetryRuleSummaries, 0],
+];
+var ListTelemetryRulesInput = [3, n0, _LTRI, 0, [_RNP, _MR, _NT], [0, 1, 0]];
+var ListTelemetryRulesOutput = [
+    3,
+    n0,
+    _LTRO,
+    0,
+    [_TRS, _NT],
+    [() => TelemetryRuleSummaries, 0],
+];
+var LogsBackupConfiguration = [3, n0, _LBC, 0, [_R, _KKA], [0, 0]];
+var LogsEncryptionConfiguration = [3, n0, _LEC, 0, [_ES, _KKA, _ECRS], [0, 0, 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, _aET],
+    [
+        0,
+        [
+            0,
+            {
+                [_hH]: _xaE,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var SourceLogsConfiguration = [3, n0, _SLC, 0, [_LGSC, _ELGS], [0, 0]];
+var StartTelemetryEnrichmentOutput = [3, n0, _STEO, 0, [_St, _AREMVA], [0, 0]];
+var StopTelemetryEnrichmentOutput = [3, n0, _STEOt, 0, [_St], [0]];
+var TagResourceInput = [3, n0, _TRI, 0, [_RARN, _T], [0, 128 | 0]];
+var TelemetryConfiguration = [
+    3,
+    n0,
+    _TCe,
+    0,
+    [_AIc, _TCS, _RTes, _RIe, _RTe, _LUTS],
+    [0, 128 | 0, 0, 0, 128 | 0, 1],
+];
+var TelemetryDestinationConfiguration = [
+    3,
+    n0,
+    _TDC,
+    0,
+    [_DT, _DP, _RID, _VPCFLP],
+    [0, 0, 1, () => VPCFlowLogParameters],
+];
+var TelemetryRule = [
+    3,
+    n0,
+    _TR,
+    0,
+    [_RTes, _TT, _DC, _Sc, _SC],
+    [0, 0, () => TelemetryDestinationConfiguration, 0, 0],
+];
+var TelemetryRuleSummary = [
+    3,
+    n0,
+    _TRSe,
+    0,
+    [_RN, _RA, _CTS, _LUTS, _RTes, _TT],
+    [0, 0, 1, 1, 0, 0],
+];
+var TooManyRequestsException = [
+    -3,
+    n0,
+    _TMRE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyRequestsException, TooManyRequestsException$1);
+var UntagResourceInput = [3, n0, _URI, 0, [_RARN, _TK], [0, 64 | 0]];
+var UpdateCentralizationRuleForOrganizationInput = [
+    3,
+    n0,
+    _UCRFOI,
+    0,
+    [_RI, _Ru],
+    [0, () => CentralizationRule],
+];
+var UpdateCentralizationRuleForOrganizationOutput = [3, n0, _UCRFOO, 0, [_RA], [0]];
+var UpdateTelemetryRuleForOrganizationInput = [
+    3,
+    n0,
+    _UTRFOI,
+    0,
+    [_RI, _Ru],
+    [0, () => TelemetryRule],
+];
+var UpdateTelemetryRuleForOrganizationOutput = [3, n0, _UTRFOO, 0, [_RA], [0]];
+var UpdateTelemetryRuleInput = [3, n0, _UTRI, 0, [_RI, _Ru], [0, () => TelemetryRule]];
+var UpdateTelemetryRuleOutput = [3, n0, _UTRO, 0, [_RA], [0]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var VPCFlowLogParameters = [3, n0, _VPCFLP, 0, [_LF, _TTr, _MAI], [0, 0, 1]];
+var __Unit = "unit";
+var ObservabilityAdminServiceException = [
+    -3,
+    _sm,
+    "ObservabilityAdminServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(ObservabilityAdminServiceException, ObservabilityAdminServiceException$1);
+var CentralizationRuleSummaries = [1, n0, _CRSen, 0, () => CentralizationRuleSummary];
+var TelemetryConfigurations = [1, n0, _TC, 0, () => TelemetryConfiguration];
+var TelemetryRuleSummaries = [1, n0, _TRS, 0, () => TelemetryRuleSummary];
+var CreateCentralizationRuleForOrganization = [
+    9,
+    n0,
+    _CCRFO,
+    {
+        [_h]: ["POST", "/CreateCentralizationRuleForOrganization", 200],
+    },
+    () => CreateCentralizationRuleForOrganizationInput,
+    () => CreateCentralizationRuleForOrganizationOutput,
+];
+var CreateTelemetryRule = [
+    9,
+    n0,
+    _CTR,
+    {
+        [_h]: ["POST", "/CreateTelemetryRule", 200],
+    },
+    () => CreateTelemetryRuleInput,
+    () => CreateTelemetryRuleOutput,
+];
+var CreateTelemetryRuleForOrganization = [
+    9,
+    n0,
+    _CTRFO,
+    {
+        [_h]: ["POST", "/CreateTelemetryRuleForOrganization", 200],
+    },
+    () => CreateTelemetryRuleForOrganizationInput,
+    () => CreateTelemetryRuleForOrganizationOutput,
+];
+var DeleteCentralizationRuleForOrganization = [
+    9,
+    n0,
+    _DCRFO,
+    {
+        [_h]: ["POST", "/DeleteCentralizationRuleForOrganization", 200],
+    },
+    () => DeleteCentralizationRuleForOrganizationInput,
+    () => __Unit,
+];
+var DeleteTelemetryRule = [
+    9,
+    n0,
+    _DTR,
+    {
+        [_h]: ["POST", "/DeleteTelemetryRule", 200],
+    },
+    () => DeleteTelemetryRuleInput,
+    () => __Unit,
+];
+var DeleteTelemetryRuleForOrganization = [
+    9,
+    n0,
+    _DTRFO,
+    {
+        [_h]: ["POST", "/DeleteTelemetryRuleForOrganization", 200],
+    },
+    () => DeleteTelemetryRuleForOrganizationInput,
+    () => __Unit,
+];
+var GetCentralizationRuleForOrganization = [
+    9,
+    n0,
+    _GCRFO,
+    {
+        [_h]: ["POST", "/GetCentralizationRuleForOrganization", 200],
+    },
+    () => GetCentralizationRuleForOrganizationInput,
+    () => GetCentralizationRuleForOrganizationOutput,
+];
+var GetTelemetryEnrichmentStatus = [
+    9,
+    n0,
+    _GTES,
+    {
+        [_h]: ["POST", "/GetTelemetryEnrichmentStatus", 200],
+    },
+    () => __Unit,
+    () => GetTelemetryEnrichmentStatusOutput,
+];
+var GetTelemetryEvaluationStatus = [
+    9,
+    n0,
+    _GTESe,
+    {
+        [_h]: ["POST", "/GetTelemetryEvaluationStatus", 200],
+    },
+    () => __Unit,
+    () => GetTelemetryEvaluationStatusOutput,
+];
+var GetTelemetryEvaluationStatusForOrganization = [
+    9,
+    n0,
+    _GTESFO,
+    {
+        [_h]: ["POST", "/GetTelemetryEvaluationStatusForOrganization", 200],
+    },
+    () => __Unit,
+    () => GetTelemetryEvaluationStatusForOrganizationOutput,
+];
+var GetTelemetryRule = [
+    9,
+    n0,
+    _GTR,
+    {
+        [_h]: ["POST", "/GetTelemetryRule", 200],
+    },
+    () => GetTelemetryRuleInput,
+    () => GetTelemetryRuleOutput,
+];
+var GetTelemetryRuleForOrganization = [
+    9,
+    n0,
+    _GTRFO,
+    {
+        [_h]: ["POST", "/GetTelemetryRuleForOrganization", 200],
+    },
+    () => GetTelemetryRuleForOrganizationInput,
+    () => GetTelemetryRuleForOrganizationOutput,
+];
+var ListCentralizationRulesForOrganization = [
+    9,
+    n0,
+    _LCRFO,
+    {
+        [_h]: ["POST", "/ListCentralizationRulesForOrganization", 200],
+    },
+    () => ListCentralizationRulesForOrganizationInput,
+    () => ListCentralizationRulesForOrganizationOutput,
+];
+var ListResourceTelemetry = [
+    9,
+    n0,
+    _LRT,
+    {
+        [_h]: ["POST", "/ListResourceTelemetry", 200],
+    },
+    () => ListResourceTelemetryInput,
+    () => ListResourceTelemetryOutput,
+];
+var ListResourceTelemetryForOrganization = [
+    9,
+    n0,
+    _LRTFO,
+    {
+        [_h]: ["POST", "/ListResourceTelemetryForOrganization", 200],
+    },
+    () => ListResourceTelemetryForOrganizationInput,
+    () => ListResourceTelemetryForOrganizationOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["POST", "/ListTagsForResource", 200],
+    },
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var ListTelemetryRules = [
+    9,
+    n0,
+    _LTR,
+    {
+        [_h]: ["POST", "/ListTelemetryRules", 200],
+    },
+    () => ListTelemetryRulesInput,
+    () => ListTelemetryRulesOutput,
+];
+var ListTelemetryRulesForOrganization = [
+    9,
+    n0,
+    _LTRFO,
+    {
+        [_h]: ["POST", "/ListTelemetryRulesForOrganization", 200],
+    },
+    () => ListTelemetryRulesForOrganizationInput,
+    () => ListTelemetryRulesForOrganizationOutput,
+];
+var StartTelemetryEnrichment = [
+    9,
+    n0,
+    _STE,
+    {
+        [_h]: ["POST", "/StartTelemetryEnrichment", 202],
+    },
+    () => __Unit,
+    () => StartTelemetryEnrichmentOutput,
+];
+var StartTelemetryEvaluation = [
+    9,
+    n0,
+    _STEt,
+    {
+        [_h]: ["POST", "/StartTelemetryEvaluation", 200],
+    },
+    () => __Unit,
+    () => __Unit,
+];
+var StartTelemetryEvaluationForOrganization = [
+    9,
+    n0,
+    _STEFO,
+    {
+        [_h]: ["POST", "/StartTelemetryEvaluationForOrganization", 200],
+    },
+    () => __Unit,
+    () => __Unit,
+];
+var StopTelemetryEnrichment = [
+    9,
+    n0,
+    _STEto,
+    {
+        [_h]: ["POST", "/StopTelemetryEnrichment", 202],
+    },
+    () => __Unit,
+    () => StopTelemetryEnrichmentOutput,
+];
+var StopTelemetryEvaluation = [
+    9,
+    n0,
+    _STEtop,
+    {
+        [_h]: ["POST", "/StopTelemetryEvaluation", 200],
+    },
+    () => __Unit,
+    () => __Unit,
+];
+var StopTelemetryEvaluationForOrganization = [
+    9,
+    n0,
+    _STEFOt,
+    {
+        [_h]: ["POST", "/StopTelemetryEvaluationForOrganization", 200],
+    },
+    () => __Unit,
+    () => __Unit,
+];
+var TagResource = [
+    9,
+    n0,
+    _TRa,
+    {
+        [_h]: ["POST", "/TagResource", 200],
+    },
+    () => TagResourceInput,
+    () => __Unit,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["POST", "/UntagResource", 200],
+    },
+    () => UntagResourceInput,
+    () => __Unit,
+];
+var UpdateCentralizationRuleForOrganization = [
+    9,
+    n0,
+    _UCRFO,
+    {
+        [_h]: ["POST", "/UpdateCentralizationRuleForOrganization", 200],
+    },
+    () => UpdateCentralizationRuleForOrganizationInput,
+    () => UpdateCentralizationRuleForOrganizationOutput,
+];
+var UpdateTelemetryRule = [
+    9,
+    n0,
+    _UTR,
+    {
+        [_h]: ["POST", "/UpdateTelemetryRule", 200],
+    },
+    () => UpdateTelemetryRuleInput,
+    () => UpdateTelemetryRuleOutput,
+];
+var UpdateTelemetryRuleForOrganization = [
+    9,
+    n0,
+    _UTRFO,
+    {
+        [_h]: ["POST", "/UpdateTelemetryRuleForOrganization", 200],
+    },
+    () => UpdateTelemetryRuleForOrganizationInput,
+    () => UpdateTelemetryRuleForOrganizationOutput,
+];
 
 class CreateCentralizationRuleForOrganizationCommand 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("ObservabilityAdmin", "CreateCentralizationRuleForOrganization", {})
     .n("ObservabilityAdminClient", "CreateCentralizationRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateCentralizationRuleForOrganizationCommand)
-    .de(de_CreateCentralizationRuleForOrganizationCommand)
+    .sc(CreateCentralizationRuleForOrganization)
     .build() {
 }
 
@@ -1199,16 +1101,11 @@ class CreateTelemetryRuleCommand 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("ObservabilityAdmin", "CreateTelemetryRule", {})
     .n("ObservabilityAdminClient", "CreateTelemetryRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateTelemetryRuleCommand)
-    .de(de_CreateTelemetryRuleCommand)
+    .sc(CreateTelemetryRule)
     .build() {
 }
 
@@ -1216,16 +1113,11 @@ class CreateTelemetryRuleForOrganizationCommand 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("ObservabilityAdmin", "CreateTelemetryRuleForOrganization", {})
     .n("ObservabilityAdminClient", "CreateTelemetryRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateTelemetryRuleForOrganizationCommand)
-    .de(de_CreateTelemetryRuleForOrganizationCommand)
+    .sc(CreateTelemetryRuleForOrganization)
     .build() {
 }
 
@@ -1233,16 +1125,11 @@ class DeleteCentralizationRuleForOrganizationCommand extends smithyClient.Comman
     .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("ObservabilityAdmin", "DeleteCentralizationRuleForOrganization", {})
     .n("ObservabilityAdminClient", "DeleteCentralizationRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteCentralizationRuleForOrganizationCommand)
-    .de(de_DeleteCentralizationRuleForOrganizationCommand)
+    .sc(DeleteCentralizationRuleForOrganization)
     .build() {
 }
 
@@ -1250,16 +1137,11 @@ class DeleteTelemetryRuleCommand 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("ObservabilityAdmin", "DeleteTelemetryRule", {})
     .n("ObservabilityAdminClient", "DeleteTelemetryRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteTelemetryRuleCommand)
-    .de(de_DeleteTelemetryRuleCommand)
+    .sc(DeleteTelemetryRule)
     .build() {
 }
 
@@ -1267,16 +1149,11 @@ class DeleteTelemetryRuleForOrganizationCommand 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("ObservabilityAdmin", "DeleteTelemetryRuleForOrganization", {})
     .n("ObservabilityAdminClient", "DeleteTelemetryRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteTelemetryRuleForOrganizationCommand)
-    .de(de_DeleteTelemetryRuleForOrganizationCommand)
+    .sc(DeleteTelemetryRuleForOrganization)
     .build() {
 }
 
@@ -1284,16 +1161,11 @@ class GetCentralizationRuleForOrganizationCommand 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("ObservabilityAdmin", "GetCentralizationRuleForOrganization", {})
     .n("ObservabilityAdminClient", "GetCentralizationRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetCentralizationRuleForOrganizationCommand)
-    .de(de_GetCentralizationRuleForOrganizationCommand)
+    .sc(GetCentralizationRuleForOrganization)
     .build() {
 }
 
@@ -1301,16 +1173,11 @@ class GetTelemetryEnrichmentStatusCommand 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("ObservabilityAdmin", "GetTelemetryEnrichmentStatus", {})
     .n("ObservabilityAdminClient", "GetTelemetryEnrichmentStatusCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTelemetryEnrichmentStatusCommand)
-    .de(de_GetTelemetryEnrichmentStatusCommand)
+    .sc(GetTelemetryEnrichmentStatus)
     .build() {
 }
 
@@ -1318,16 +1185,11 @@ class GetTelemetryEvaluationStatusCommand 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("ObservabilityAdmin", "GetTelemetryEvaluationStatus", {})
     .n("ObservabilityAdminClient", "GetTelemetryEvaluationStatusCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTelemetryEvaluationStatusCommand)
-    .de(de_GetTelemetryEvaluationStatusCommand)
+    .sc(GetTelemetryEvaluationStatus)
     .build() {
 }
 
@@ -1335,16 +1197,11 @@ class GetTelemetryEvaluationStatusForOrganizationCommand extends smithyClient.Co
     .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("ObservabilityAdmin", "GetTelemetryEvaluationStatusForOrganization", {})
     .n("ObservabilityAdminClient", "GetTelemetryEvaluationStatusForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTelemetryEvaluationStatusForOrganizationCommand)
-    .de(de_GetTelemetryEvaluationStatusForOrganizationCommand)
+    .sc(GetTelemetryEvaluationStatusForOrganization)
     .build() {
 }
 
@@ -1352,16 +1209,11 @@ class GetTelemetryRuleCommand 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("ObservabilityAdmin", "GetTelemetryRule", {})
     .n("ObservabilityAdminClient", "GetTelemetryRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTelemetryRuleCommand)
-    .de(de_GetTelemetryRuleCommand)
+    .sc(GetTelemetryRule)
     .build() {
 }
 
@@ -1369,16 +1221,11 @@ class GetTelemetryRuleForOrganizationCommand 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("ObservabilityAdmin", "GetTelemetryRuleForOrganization", {})
     .n("ObservabilityAdminClient", "GetTelemetryRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTelemetryRuleForOrganizationCommand)
-    .de(de_GetTelemetryRuleForOrganizationCommand)
+    .sc(GetTelemetryRuleForOrganization)
     .build() {
 }
 
@@ -1386,16 +1233,11 @@ class ListCentralizationRulesForOrganizationCommand 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("ObservabilityAdmin", "ListCentralizationRulesForOrganization", {})
     .n("ObservabilityAdminClient", "ListCentralizationRulesForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_ListCentralizationRulesForOrganizationCommand)
-    .de(de_ListCentralizationRulesForOrganizationCommand)
+    .sc(ListCentralizationRulesForOrganization)
     .build() {
 }
 
@@ -1403,16 +1245,11 @@ class ListResourceTelemetryCommand 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("ObservabilityAdmin", "ListResourceTelemetry", {})
     .n("ObservabilityAdminClient", "ListResourceTelemetryCommand")
-    .f(void 0, void 0)
-    .ser(se_ListResourceTelemetryCommand)
-    .de(de_ListResourceTelemetryCommand)
+    .sc(ListResourceTelemetry)
     .build() {
 }
 
@@ -1420,16 +1257,11 @@ class ListResourceTelemetryForOrganizationCommand 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("ObservabilityAdmin", "ListResourceTelemetryForOrganization", {})
     .n("ObservabilityAdminClient", "ListResourceTelemetryForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_ListResourceTelemetryForOrganizationCommand)
-    .de(de_ListResourceTelemetryForOrganizationCommand)
+    .sc(ListResourceTelemetryForOrganization)
     .build() {
 }
 
@@ -1437,16 +1269,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("ObservabilityAdmin", "ListTagsForResource", {})
     .n("ObservabilityAdminClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1454,16 +1281,11 @@ class ListTelemetryRulesCommand 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("ObservabilityAdmin", "ListTelemetryRules", {})
     .n("ObservabilityAdminClient", "ListTelemetryRulesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTelemetryRulesCommand)
-    .de(de_ListTelemetryRulesCommand)
+    .sc(ListTelemetryRules)
     .build() {
 }
 
@@ -1471,16 +1293,11 @@ class ListTelemetryRulesForOrganizationCommand 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("ObservabilityAdmin", "ListTelemetryRulesForOrganization", {})
     .n("ObservabilityAdminClient", "ListTelemetryRulesForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTelemetryRulesForOrganizationCommand)
-    .de(de_ListTelemetryRulesForOrganizationCommand)
+    .sc(ListTelemetryRulesForOrganization)
     .build() {
 }
 
@@ -1488,16 +1305,11 @@ class StartTelemetryEnrichmentCommand 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("ObservabilityAdmin", "StartTelemetryEnrichment", {})
     .n("ObservabilityAdminClient", "StartTelemetryEnrichmentCommand")
-    .f(void 0, void 0)
-    .ser(se_StartTelemetryEnrichmentCommand)
-    .de(de_StartTelemetryEnrichmentCommand)
+    .sc(StartTelemetryEnrichment)
     .build() {
 }
 
@@ -1505,16 +1317,11 @@ class StartTelemetryEvaluationCommand 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("ObservabilityAdmin", "StartTelemetryEvaluation", {})
     .n("ObservabilityAdminClient", "StartTelemetryEvaluationCommand")
-    .f(void 0, void 0)
-    .ser(se_StartTelemetryEvaluationCommand)
-    .de(de_StartTelemetryEvaluationCommand)
+    .sc(StartTelemetryEvaluation)
     .build() {
 }
 
@@ -1522,16 +1329,11 @@ class StartTelemetryEvaluationForOrganizationCommand extends smithyClient.Comman
     .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("ObservabilityAdmin", "StartTelemetryEvaluationForOrganization", {})
     .n("ObservabilityAdminClient", "StartTelemetryEvaluationForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_StartTelemetryEvaluationForOrganizationCommand)
-    .de(de_StartTelemetryEvaluationForOrganizationCommand)
+    .sc(StartTelemetryEvaluationForOrganization)
     .build() {
 }
 
@@ -1539,16 +1341,11 @@ class StopTelemetryEnrichmentCommand 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("ObservabilityAdmin", "StopTelemetryEnrichment", {})
     .n("ObservabilityAdminClient", "StopTelemetryEnrichmentCommand")
-    .f(void 0, void 0)
-    .ser(se_StopTelemetryEnrichmentCommand)
-    .de(de_StopTelemetryEnrichmentCommand)
+    .sc(StopTelemetryEnrichment)
     .build() {
 }
 
@@ -1556,16 +1353,11 @@ class StopTelemetryEvaluationCommand 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("ObservabilityAdmin", "StopTelemetryEvaluation", {})
     .n("ObservabilityAdminClient", "StopTelemetryEvaluationCommand")
-    .f(void 0, void 0)
-    .ser(se_StopTelemetryEvaluationCommand)
-    .de(de_StopTelemetryEvaluationCommand)
+    .sc(StopTelemetryEvaluation)
     .build() {
 }
 
@@ -1573,16 +1365,11 @@ class StopTelemetryEvaluationForOrganizationCommand 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("ObservabilityAdmin", "StopTelemetryEvaluationForOrganization", {})
     .n("ObservabilityAdminClient", "StopTelemetryEvaluationForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_StopTelemetryEvaluationForOrganizationCommand)
-    .de(de_StopTelemetryEvaluationForOrganizationCommand)
+    .sc(StopTelemetryEvaluationForOrganization)
     .build() {
 }
 
@@ -1590,16 +1377,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("ObservabilityAdmin", "TagResource", {})
     .n("ObservabilityAdminClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1607,16 +1389,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("ObservabilityAdmin", "UntagResource", {})
     .n("ObservabilityAdminClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1624,16 +1401,11 @@ class UpdateCentralizationRuleForOrganizationCommand extends smithyClient.Comman
     .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("ObservabilityAdmin", "UpdateCentralizationRuleForOrganization", {})
     .n("ObservabilityAdminClient", "UpdateCentralizationRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateCentralizationRuleForOrganizationCommand)
-    .de(de_UpdateCentralizationRuleForOrganizationCommand)
+    .sc(UpdateCentralizationRuleForOrganization)
     .build() {
 }
 
@@ -1641,16 +1413,11 @@ class UpdateTelemetryRuleCommand 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("ObservabilityAdmin", "UpdateTelemetryRule", {})
     .n("ObservabilityAdminClient", "UpdateTelemetryRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateTelemetryRuleCommand)
-    .de(de_UpdateTelemetryRuleCommand)
+    .sc(UpdateTelemetryRule)
     .build() {
 }
 
@@ -1658,16 +1425,11 @@ class UpdateTelemetryRuleForOrganizationCommand 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("ObservabilityAdmin", "UpdateTelemetryRuleForOrganization", {})
     .n("ObservabilityAdminClient", "UpdateTelemetryRuleForOrganizationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateTelemetryRuleForOrganizationCommand)
-    .de(de_UpdateTelemetryRuleForOrganizationCommand)
+    .sc(UpdateTelemetryRuleForOrganization)
     .build() {
 }
 
@@ -1724,9 +1486,9 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.CentralizationFailureReason = CentralizationFailureReason;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateCentralizationRuleForOrganizationCommand = CreateCentralizationRuleForOrganizationCommand;
 exports.CreateTelemetryRuleCommand = CreateTelemetryRuleCommand;
 exports.CreateTelemetryRuleForOrganizationCommand = CreateTelemetryRuleForOrganizationCommand;
@@ -1743,7 +1505,7 @@ exports.GetTelemetryEvaluationStatusCommand = GetTelemetryEvaluationStatusComman
 exports.GetTelemetryEvaluationStatusForOrganizationCommand = GetTelemetryEvaluationStatusForOrganizationCommand;
 exports.GetTelemetryRuleCommand = GetTelemetryRuleCommand;
 exports.GetTelemetryRuleForOrganizationCommand = GetTelemetryRuleForOrganizationCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListCentralizationRulesForOrganizationCommand = ListCentralizationRulesForOrganizationCommand;
 exports.ListResourceTelemetryCommand = ListResourceTelemetryCommand;
 exports.ListResourceTelemetryForOrganizationCommand = ListResourceTelemetryForOrganizationCommand;
@@ -1752,11 +1514,11 @@ exports.ListTelemetryRulesCommand = ListTelemetryRulesCommand;
 exports.ListTelemetryRulesForOrganizationCommand = ListTelemetryRulesForOrganizationCommand;
 exports.ObservabilityAdmin = ObservabilityAdmin;
 exports.ObservabilityAdminClient = ObservabilityAdminClient;
-exports.ObservabilityAdminServiceException = ObservabilityAdminServiceException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ObservabilityAdminServiceException = ObservabilityAdminServiceException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResourceType = ResourceType;
 exports.RuleHealth = RuleHealth;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.StartTelemetryEnrichmentCommand = StartTelemetryEnrichmentCommand;
 exports.StartTelemetryEvaluationCommand = StartTelemetryEvaluationCommand;
 exports.StartTelemetryEvaluationForOrganizationCommand = StartTelemetryEvaluationForOrganizationCommand;
@@ -1768,12 +1530,12 @@ exports.TagResourceCommand = TagResourceCommand;
 exports.TelemetryEnrichmentStatus = TelemetryEnrichmentStatus;
 exports.TelemetryState = TelemetryState;
 exports.TelemetryType = TelemetryType;
-exports.TooManyRequestsException = TooManyRequestsException;
+exports.TooManyRequestsException = TooManyRequestsException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateCentralizationRuleForOrganizationCommand = UpdateCentralizationRuleForOrganizationCommand;
 exports.UpdateTelemetryRuleCommand = UpdateTelemetryRuleCommand;
 exports.UpdateTelemetryRuleForOrganizationCommand = UpdateTelemetryRuleForOrganizationCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListCentralizationRulesForOrganization = paginateListCentralizationRulesForOrganization;
 exports.paginateListResourceTelemetry = paginateListResourceTelemetry;
 exports.paginateListResourceTelemetryForOrganization = paginateListResourceTelemetryForOrganization;