@aws-sdk/client-xray 3.928.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 XRayClient 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,12 +110,12 @@ class XRayClient extends smithyClient.Client {
     }
 }
 
-class XRayServiceException extends smithyClient.ServiceException {
+let XRayServiceException$1 = class XRayServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, XRayServiceException.prototype);
     }
-}
+};
 
 exports.AnnotationValue = void 0;
 (function (AnnotationValue) {
@@ -129,7 +129,7 @@ exports.AnnotationValue = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.AnnotationValue || (exports.AnnotationValue = {}));
-class InvalidRequestException extends XRayServiceException {
+let InvalidRequestException$1 = class InvalidRequestException extends XRayServiceException$1 {
     name = "InvalidRequestException";
     $fault = "client";
     Message;
@@ -142,8 +142,8 @@ class InvalidRequestException extends XRayServiceException {
         Object.setPrototypeOf(this, InvalidRequestException.prototype);
         this.Message = opts.Message;
     }
-}
-class ThrottledException extends XRayServiceException {
+};
+let ThrottledException$1 = class ThrottledException extends XRayServiceException$1 {
     name = "ThrottledException";
     $fault = "client";
     Message;
@@ -156,8 +156,8 @@ class ThrottledException extends XRayServiceException {
         Object.setPrototypeOf(this, ThrottledException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceNotFoundException extends XRayServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends XRayServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -172,8 +172,8 @@ class ResourceNotFoundException extends XRayServiceException {
         this.Message = opts.Message;
         this.ResourceName = opts.ResourceName;
     }
-}
-class RuleLimitExceededException extends XRayServiceException {
+};
+let RuleLimitExceededException$1 = class RuleLimitExceededException extends XRayServiceException$1 {
     name = "RuleLimitExceededException";
     $fault = "client";
     Message;
@@ -186,8 +186,8 @@ class RuleLimitExceededException extends XRayServiceException {
         Object.setPrototypeOf(this, RuleLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidPolicyRevisionIdException extends XRayServiceException {
+};
+let InvalidPolicyRevisionIdException$1 = class InvalidPolicyRevisionIdException extends XRayServiceException$1 {
     name = "InvalidPolicyRevisionIdException";
     $fault = "client";
     Message;
@@ -200,7 +200,7 @@ class InvalidPolicyRevisionIdException extends XRayServiceException {
         Object.setPrototypeOf(this, InvalidPolicyRevisionIdException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const EncryptionStatus = {
     ACTIVE: "ACTIVE",
     UPDATING: "UPDATING",
@@ -253,7 +253,7 @@ const TraceFormatType = {
     OTEL: "OTEL",
     XRAY: "XRAY",
 };
-class LockoutPreventionException extends XRayServiceException {
+let LockoutPreventionException$1 = class LockoutPreventionException extends XRayServiceException$1 {
     name = "LockoutPreventionException";
     $fault = "client";
     Message;
@@ -266,8 +266,8 @@ class LockoutPreventionException extends XRayServiceException {
         Object.setPrototypeOf(this, LockoutPreventionException.prototype);
         this.Message = opts.Message;
     }
-}
-class MalformedPolicyDocumentException extends XRayServiceException {
+};
+let MalformedPolicyDocumentException$1 = class MalformedPolicyDocumentException extends XRayServiceException$1 {
     name = "MalformedPolicyDocumentException";
     $fault = "client";
     Message;
@@ -280,8 +280,8 @@ class MalformedPolicyDocumentException extends XRayServiceException {
         Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype);
         this.Message = opts.Message;
     }
-}
-class PolicyCountLimitExceededException extends XRayServiceException {
+};
+let PolicyCountLimitExceededException$1 = class PolicyCountLimitExceededException extends XRayServiceException$1 {
     name = "PolicyCountLimitExceededException";
     $fault = "client";
     Message;
@@ -294,8 +294,8 @@ class PolicyCountLimitExceededException extends XRayServiceException {
         Object.setPrototypeOf(this, PolicyCountLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class PolicySizeLimitExceededException extends XRayServiceException {
+};
+let PolicySizeLimitExceededException$1 = class PolicySizeLimitExceededException extends XRayServiceException$1 {
     name = "PolicySizeLimitExceededException";
     $fault = "client";
     Message;
@@ -308,8 +308,8 @@ class PolicySizeLimitExceededException extends XRayServiceException {
         Object.setPrototypeOf(this, PolicySizeLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class TooManyTagsException extends XRayServiceException {
+};
+let TooManyTagsException$1 = class TooManyTagsException extends XRayServiceException$1 {
     name = "TooManyTagsException";
     $fault = "client";
     Message;
@@ -324,7 +324,7 @@ class TooManyTagsException extends XRayServiceException {
         this.Message = opts.Message;
         this.ResourceName = opts.ResourceName;
     }
-}
+};
 exports.IndexingRuleValueUpdate = void 0;
 (function (IndexingRuleValueUpdate) {
     IndexingRuleValueUpdate.visit = (value, visitor) => {
@@ -334,1838 +334,1556 @@ exports.IndexingRuleValueUpdate = void 0;
     };
 })(exports.IndexingRuleValueUpdate || (exports.IndexingRuleValueUpdate = {}));
 
-const se_BatchGetTracesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/Traces");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-        TraceIds: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CancelTraceRetrievalCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CancelTraceRetrieval");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RetrievalToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateGroupCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateGroup");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        FilterExpression: [],
-        GroupName: [],
-        InsightsConfiguration: (_) => smithyClient._json(_),
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateSamplingRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/CreateSamplingRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        SamplingRule: (_) => se_SamplingRule(_),
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteGroupCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteGroup");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        GroupARN: [],
-        GroupName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteResourcePolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteResourcePolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        PolicyName: [],
-        PolicyRevisionId: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteSamplingRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/DeleteSamplingRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        RuleARN: [],
-        RuleName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetEncryptionConfigCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/EncryptionConfig");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetGroupCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetGroup");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        GroupARN: [],
-        GroupName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetGroupsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/Groups");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetIndexingRulesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetIndexingRules");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetInsightCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/Insight");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        InsightId: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetInsightEventsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/InsightEvents");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        InsightId: [],
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetInsightImpactGraphCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/InsightImpactGraph");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        InsightId: [],
-        NextToken: [],
-        StartTime: (_) => _.getTime() / 1_000,
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetInsightSummariesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/InsightSummaries");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        GroupARN: [],
-        GroupName: [],
-        MaxResults: [],
-        NextToken: [],
-        StartTime: (_) => _.getTime() / 1_000,
-        States: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetRetrievedTracesGraphCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetRetrievedTracesGraph");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-        RetrievalToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetSamplingRulesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/GetSamplingRules");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetSamplingStatisticSummariesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/SamplingStatisticSummaries");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetSamplingTargetsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/SamplingTargets");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        SamplingBoostStatisticsDocuments: (_) => se_SamplingBoostStatisticsDocumentList(_),
-        SamplingStatisticsDocuments: (_) => se_SamplingStatisticsDocumentList(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetServiceGraphCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ServiceGraph");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        GroupARN: [],
-        GroupName: [],
-        NextToken: [],
-        StartTime: (_) => _.getTime() / 1_000,
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTimeSeriesServiceStatisticsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/TimeSeriesServiceStatistics");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        EntitySelectorExpression: [],
-        ForecastStatistics: [],
-        GroupARN: [],
-        GroupName: [],
-        NextToken: [],
-        Period: [],
-        StartTime: (_) => _.getTime() / 1_000,
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTraceGraphCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/TraceGraph");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-        TraceIds: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTraceSegmentDestinationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/GetTraceSegmentDestination");
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetTraceSummariesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/TraceSummaries");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        FilterExpression: [],
-        NextToken: [],
-        Sampling: [],
-        SamplingStrategy: (_) => se_SamplingStrategy(_),
-        StartTime: (_) => _.getTime() / 1_000,
-        TimeRangeType: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListResourcePoliciesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListResourcePolicies");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListRetrievedTracesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/ListRetrievedTraces");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        NextToken: [],
-        RetrievalToken: [],
-        TraceFormat: [],
-    }));
-    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, {
-        NextToken: [],
-        ResourceARN: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_PutEncryptionConfigCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/PutEncryptionConfig");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        KeyId: [],
-        Type: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_PutResourcePolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/PutResourcePolicy");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        BypassPolicyLockoutCheck: [],
-        PolicyDocument: [],
-        PolicyName: [],
-        PolicyRevisionId: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_PutTelemetryRecordsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/TelemetryRecords");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EC2InstanceId: [],
-        Hostname: [],
-        ResourceARN: [],
-        TelemetryRecords: (_) => se_TelemetryRecordList(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_PutTraceSegmentsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/TraceSegments");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        TraceSegmentDocuments: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartTraceRetrievalCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/StartTraceRetrieval");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        StartTime: (_) => _.getTime() / 1_000,
-        TraceIds: (_) => smithyClient._json(_),
-    }));
-    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_UpdateGroupCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateGroup");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        FilterExpression: [],
-        GroupARN: [],
-        GroupName: [],
-        InsightsConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateIndexingRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateIndexingRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Name: [],
-        Rule: (_) => se_IndexingRuleValueUpdate(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateSamplingRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateSamplingRule");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        SamplingRuleUpdate: (_) => se_SamplingRuleUpdate(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateTraceSegmentDestinationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/UpdateTraceSegmentDestination");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Destination: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_BatchGetTracesCommand = 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,
-        Traces: (_) => de_TraceList(_),
-        UnprocessedTraceIds: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CancelTraceRetrievalCommand = 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_CreateGroupCommand = 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, {
-        Group: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateSamplingRuleCommand = 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, {
-        SamplingRuleRecord: (_) => de_SamplingRuleRecord(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteGroupCommand = 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_DeleteResourcePolicyCommand = 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_DeleteSamplingRuleCommand = 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, {
-        SamplingRuleRecord: (_) => de_SamplingRuleRecord(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetEncryptionConfigCommand = 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, {
-        EncryptionConfig: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetGroupCommand = 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, {
-        Group: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetGroupsCommand = 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, {
-        Groups: smithyClient._json,
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetIndexingRulesCommand = 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, {
-        IndexingRules: (_) => de_IndexingRuleList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetInsightCommand = 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, {
-        Insight: (_) => de_Insight(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetInsightEventsCommand = 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, {
-        InsightEvents: (_) => de_InsightEventList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetInsightImpactGraphCommand = 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, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InsightId: smithyClient.expectString,
-        NextToken: smithyClient.expectString,
-        ServiceGraphEndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ServiceGraphStartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Services: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetInsightSummariesCommand = 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, {
-        InsightSummaries: (_) => de_InsightSummaryList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetRetrievedTracesGraphCommand = 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,
-        RetrievalStatus: smithyClient.expectString,
-        Services: (_) => de_RetrievedServicesList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSamplingRulesCommand = 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,
-        SamplingRuleRecords: (_) => de_SamplingRuleRecordList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSamplingStatisticSummariesCommand = 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,
-        SamplingStatisticSummaries: (_) => de_SamplingStatisticSummaryList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSamplingTargetsCommand = 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, {
-        LastRuleModification: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SamplingTargetDocuments: (_) => de_SamplingTargetDocumentList(_),
-        UnprocessedBoostStatistics: smithyClient._json,
-        UnprocessedStatistics: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetServiceGraphCommand = 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, {
-        ContainsOldGroupVersions: smithyClient.expectBoolean,
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        Services: (_) => de_ServiceList(_),
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTimeSeriesServiceStatisticsCommand = 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, {
-        ContainsOldGroupVersions: smithyClient.expectBoolean,
-        NextToken: smithyClient.expectString,
-        TimeSeriesServiceStatistics: (_) => de_TimeSeriesServiceStatisticsList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTraceGraphCommand = 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,
-        Services: (_) => de_ServiceList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTraceSegmentDestinationCommand = 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, {
-        Destination: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTraceSummariesCommand = 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, {
-        ApproximateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        TraceSummaries: (_) => de_TraceSummaryList(_),
-        TracesProcessedCount: smithyClient.expectLong,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListResourcePoliciesCommand = 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,
-        ResourcePolicies: (_) => de_ResourcePolicyList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListRetrievedTracesCommand = 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,
-        RetrievalStatus: smithyClient.expectString,
-        TraceFormat: smithyClient.expectString,
-        Traces: (_) => de_TraceSpanList(_),
-    });
-    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, {
-        NextToken: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutEncryptionConfigCommand = 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, {
-        EncryptionConfig: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutResourcePolicyCommand = 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, {
-        ResourcePolicy: (_) => de_ResourcePolicy(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutTelemetryRecordsCommand = 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_PutTraceSegmentsCommand = 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, {
-        UnprocessedTraceSegments: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartTraceRetrievalCommand = 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, {
-        RetrievalToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    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_UpdateGroupCommand = 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, {
-        Group: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateIndexingRuleCommand = 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, {
-        IndexingRule: (_) => de_IndexingRule(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateSamplingRuleCommand = 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, {
-        SamplingRuleRecord: (_) => de_SamplingRuleRecord(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateTraceSegmentDestinationCommand = 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, {
-        Destination: smithyClient.expectString,
-        Status: 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 "InvalidRequestException":
-        case "com.amazonaws.xray#InvalidRequestException":
-            throw await de_InvalidRequestExceptionRes(parsedOutput);
-        case "ThrottledException":
-        case "com.amazonaws.xray#ThrottledException":
-            throw await de_ThrottledExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.xray#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "RuleLimitExceededException":
-        case "com.amazonaws.xray#RuleLimitExceededException":
-            throw await de_RuleLimitExceededExceptionRes(parsedOutput);
-        case "InvalidPolicyRevisionIdException":
-        case "com.amazonaws.xray#InvalidPolicyRevisionIdException":
-            throw await de_InvalidPolicyRevisionIdExceptionRes(parsedOutput);
-        case "LockoutPreventionException":
-        case "com.amazonaws.xray#LockoutPreventionException":
-            throw await de_LockoutPreventionExceptionRes(parsedOutput);
-        case "MalformedPolicyDocumentException":
-        case "com.amazonaws.xray#MalformedPolicyDocumentException":
-            throw await de_MalformedPolicyDocumentExceptionRes(parsedOutput);
-        case "PolicyCountLimitExceededException":
-        case "com.amazonaws.xray#PolicyCountLimitExceededException":
-            throw await de_PolicyCountLimitExceededExceptionRes(parsedOutput);
-        case "PolicySizeLimitExceededException":
-        case "com.amazonaws.xray#PolicySizeLimitExceededException":
-            throw await de_PolicySizeLimitExceededExceptionRes(parsedOutput);
-        case "TooManyTagsException":
-        case "com.amazonaws.xray#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(XRayServiceException);
-const de_InvalidPolicyRevisionIdExceptionRes = 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 InvalidPolicyRevisionIdException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidRequestExceptionRes = 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 InvalidRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_LockoutPreventionExceptionRes = 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 LockoutPreventionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_MalformedPolicyDocumentExceptionRes = 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 MalformedPolicyDocumentException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_PolicyCountLimitExceededExceptionRes = 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 PolicyCountLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_PolicySizeLimitExceededExceptionRes = 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 PolicySizeLimitExceededException({
-        $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,
-        ResourceName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_RuleLimitExceededExceptionRes = 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 RuleLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottledExceptionRes = 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 ThrottledException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        ResourceName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new TooManyTagsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_IndexingRuleValueUpdate = (input, context) => {
-    return exports.IndexingRuleValueUpdate.visit(input, {
-        Probabilistic: (value) => ({ Probabilistic: se_ProbabilisticRuleValueUpdate(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_ProbabilisticRuleValueUpdate = (input, context) => {
-    return smithyClient.take(input, {
-        DesiredSamplingPercentage: smithyClient.serializeFloat,
-    });
-};
-const se_SamplingBoostStatisticsDocument = (input, context) => {
-    return smithyClient.take(input, {
-        AnomalyCount: [],
-        RuleName: [],
-        SampledAnomalyCount: [],
-        ServiceName: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-        TotalCount: [],
-    });
-};
-const se_SamplingBoostStatisticsDocumentList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_SamplingBoostStatisticsDocument(entry);
-    });
-};
-const se_SamplingRateBoost = (input, context) => {
-    return smithyClient.take(input, {
-        CooldownWindowMinutes: [],
-        MaxRate: smithyClient.serializeFloat,
-    });
-};
-const se_SamplingRule = (input, context) => {
-    return smithyClient.take(input, {
-        Attributes: smithyClient._json,
-        FixedRate: smithyClient.serializeFloat,
-        HTTPMethod: [],
-        Host: [],
-        Priority: [],
-        ReservoirSize: [],
-        ResourceARN: [],
-        RuleARN: [],
-        RuleName: [],
-        SamplingRateBoost: (_) => se_SamplingRateBoost(_),
-        ServiceName: [],
-        ServiceType: [],
-        URLPath: [],
-        Version: [],
-    });
-};
-const se_SamplingRuleUpdate = (input, context) => {
-    return smithyClient.take(input, {
-        Attributes: smithyClient._json,
-        FixedRate: smithyClient.serializeFloat,
-        HTTPMethod: [],
-        Host: [],
-        Priority: [],
-        ReservoirSize: [],
-        ResourceARN: [],
-        RuleARN: [],
-        RuleName: [],
-        SamplingRateBoost: (_) => se_SamplingRateBoost(_),
-        ServiceName: [],
-        ServiceType: [],
-        URLPath: [],
-    });
-};
-const se_SamplingStatisticsDocument = (input, context) => {
-    return smithyClient.take(input, {
-        BorrowCount: [],
-        ClientID: [],
-        RequestCount: [],
-        RuleName: [],
-        SampledCount: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_SamplingStatisticsDocumentList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_SamplingStatisticsDocument(entry);
-    });
-};
-const se_SamplingStrategy = (input, context) => {
-    return smithyClient.take(input, {
-        Name: [],
-        Value: smithyClient.serializeFloat,
-    });
-};
-const se_TelemetryRecord = (input, context) => {
-    return smithyClient.take(input, {
-        BackendConnectionErrors: smithyClient._json,
-        SegmentsReceivedCount: [],
-        SegmentsRejectedCount: [],
-        SegmentsSentCount: [],
-        SegmentsSpilloverCount: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-    });
-};
-const se_TelemetryRecordList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_TelemetryRecord(entry);
-    });
-};
-const de_Annotations = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_ValuesWithServiceIds(value);
-        return acc;
-    }, {});
-};
-const de_AnnotationValue = (output, context) => {
-    if (smithyClient.expectBoolean(output.BooleanValue) !== undefined) {
-        return { BooleanValue: smithyClient.expectBoolean(output.BooleanValue) };
-    }
-    if (smithyClient.limitedParseDouble(output.NumberValue) !== undefined) {
-        return { NumberValue: smithyClient.limitedParseDouble(output.NumberValue) };
-    }
-    if (smithyClient.expectString(output.StringValue) !== undefined) {
-        return { StringValue: smithyClient.expectString(output.StringValue) };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_Edge = (output, context) => {
-    return smithyClient.take(output, {
-        Aliases: smithyClient._json,
-        EdgeType: smithyClient.expectString,
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ReceivedEventAgeHistogram: (_) => de_Histogram(_),
-        ReferenceId: smithyClient.expectInt32,
-        ResponseTimeHistogram: (_) => de_Histogram(_),
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SummaryStatistics: (_) => de_EdgeStatistics(_),
-    });
-};
-const de_EdgeList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Edge(entry);
-    });
-    return retVal;
-};
-const de_EdgeStatistics = (output, context) => {
-    return smithyClient.take(output, {
-        ErrorStatistics: smithyClient._json,
-        FaultStatistics: smithyClient._json,
-        OkCount: smithyClient.expectLong,
-        TotalCount: smithyClient.expectLong,
-        TotalResponseTime: smithyClient.limitedParseDouble,
-    });
-};
-const de_Histogram = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_HistogramEntry(entry);
-    });
-    return retVal;
-};
-const de_HistogramEntry = (output, context) => {
-    return smithyClient.take(output, {
-        Count: smithyClient.expectInt32,
-        Value: smithyClient.limitedParseDouble,
-    });
-};
-const de_IndexingRule = (output, context) => {
-    return smithyClient.take(output, {
-        ModifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-        Rule: (_) => de_IndexingRuleValue(core$1.awsExpectUnion(_)),
-    });
-};
-const de_IndexingRuleList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_IndexingRule(entry);
-    });
-    return retVal;
-};
-const de_IndexingRuleValue = (output, context) => {
-    if (output.Probabilistic != null) {
-        return {
-            Probabilistic: de_ProbabilisticRuleValue(output.Probabilistic),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_Insight = (output, context) => {
-    return smithyClient.take(output, {
-        Categories: smithyClient._json,
-        ClientRequestImpactStatistics: smithyClient._json,
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        GroupARN: smithyClient.expectString,
-        GroupName: smithyClient.expectString,
-        InsightId: smithyClient.expectString,
-        RootCauseServiceId: smithyClient._json,
-        RootCauseServiceRequestImpactStatistics: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        State: smithyClient.expectString,
-        Summary: smithyClient.expectString,
-        TopAnomalousServices: smithyClient._json,
-    });
-};
-const de_InsightEvent = (output, context) => {
-    return smithyClient.take(output, {
-        ClientRequestImpactStatistics: smithyClient._json,
-        EventTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        RootCauseServiceRequestImpactStatistics: smithyClient._json,
-        Summary: smithyClient.expectString,
-        TopAnomalousServices: smithyClient._json,
-    });
-};
-const de_InsightEventList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_InsightEvent(entry);
-    });
-    return retVal;
-};
-const de_InsightSummary = (output, context) => {
-    return smithyClient.take(output, {
-        Categories: smithyClient._json,
-        ClientRequestImpactStatistics: smithyClient._json,
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        GroupARN: smithyClient.expectString,
-        GroupName: smithyClient.expectString,
-        InsightId: smithyClient.expectString,
-        LastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        RootCauseServiceId: smithyClient._json,
-        RootCauseServiceRequestImpactStatistics: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        State: smithyClient.expectString,
-        Summary: smithyClient.expectString,
-        TopAnomalousServices: smithyClient._json,
-    });
-};
-const de_InsightSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_InsightSummary(entry);
-    });
-    return retVal;
-};
-const de_ProbabilisticRuleValue = (output, context) => {
-    return smithyClient.take(output, {
-        ActualSamplingPercentage: smithyClient.limitedParseDouble,
-        DesiredSamplingPercentage: smithyClient.limitedParseDouble,
-    });
-};
-const de_ResourcePolicy = (output, context) => {
-    return smithyClient.take(output, {
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        PolicyDocument: smithyClient.expectString,
-        PolicyName: smithyClient.expectString,
-        PolicyRevisionId: smithyClient.expectString,
-    });
-};
-const de_ResourcePolicyList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ResourcePolicy(entry);
-    });
-    return retVal;
-};
-const de_ResponseTimeRootCause = (output, context) => {
-    return smithyClient.take(output, {
-        ClientImpacting: smithyClient.expectBoolean,
-        Services: (_) => de_ResponseTimeRootCauseServices(_),
-    });
-};
-const de_ResponseTimeRootCauseEntity = (output, context) => {
-    return smithyClient.take(output, {
-        Coverage: smithyClient.limitedParseDouble,
-        Name: smithyClient.expectString,
-        Remote: smithyClient.expectBoolean,
-    });
-};
-const de_ResponseTimeRootCauseEntityPath = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ResponseTimeRootCauseEntity(entry);
-    });
-    return retVal;
-};
-const de_ResponseTimeRootCauses = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ResponseTimeRootCause(entry);
-    });
-    return retVal;
-};
-const de_ResponseTimeRootCauseService = (output, context) => {
-    return smithyClient.take(output, {
-        AccountId: smithyClient.expectString,
-        EntityPath: (_) => de_ResponseTimeRootCauseEntityPath(_),
-        Inferred: smithyClient.expectBoolean,
-        Name: smithyClient.expectString,
-        Names: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-};
-const de_ResponseTimeRootCauseServices = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ResponseTimeRootCauseService(entry);
-    });
-    return retVal;
-};
-const de_RetrievedService = (output, context) => {
-    return smithyClient.take(output, {
-        Links: smithyClient._json,
-        Service: (_) => de_Service(_),
-    });
-};
-const de_RetrievedServicesList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_RetrievedService(entry);
-    });
-    return retVal;
-};
-const de_RetrievedTrace = (output, context) => {
-    return smithyClient.take(output, {
-        Duration: smithyClient.limitedParseDouble,
-        Id: smithyClient.expectString,
-        Spans: smithyClient._json,
-    });
-};
-const de_SamplingBoost = (output, context) => {
-    return smithyClient.take(output, {
-        BoostRate: smithyClient.limitedParseDouble,
-        BoostRateTTL: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_SamplingRateBoost = (output, context) => {
-    return smithyClient.take(output, {
-        CooldownWindowMinutes: smithyClient.expectInt32,
-        MaxRate: smithyClient.limitedParseDouble,
-    });
-};
-const de_SamplingRule = (output, context) => {
-    return smithyClient.take(output, {
-        Attributes: smithyClient._json,
-        FixedRate: smithyClient.limitedParseDouble,
-        HTTPMethod: smithyClient.expectString,
-        Host: smithyClient.expectString,
-        Priority: smithyClient.expectInt32,
-        ReservoirSize: smithyClient.expectInt32,
-        ResourceARN: smithyClient.expectString,
-        RuleARN: smithyClient.expectString,
-        RuleName: smithyClient.expectString,
-        SamplingRateBoost: (_) => de_SamplingRateBoost(_),
-        ServiceName: smithyClient.expectString,
-        ServiceType: smithyClient.expectString,
-        URLPath: smithyClient.expectString,
-        Version: smithyClient.expectInt32,
-    });
-};
-const de_SamplingRuleRecord = (output, context) => {
-    return smithyClient.take(output, {
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ModifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SamplingRule: (_) => de_SamplingRule(_),
-    });
-};
-const de_SamplingRuleRecordList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SamplingRuleRecord(entry);
-    });
-    return retVal;
-};
-const de_SamplingStatisticSummary = (output, context) => {
-    return smithyClient.take(output, {
-        BorrowCount: smithyClient.expectInt32,
-        RequestCount: smithyClient.expectInt32,
-        RuleName: smithyClient.expectString,
-        SampledCount: smithyClient.expectInt32,
-        Timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_SamplingStatisticSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SamplingStatisticSummary(entry);
-    });
-    return retVal;
-};
-const de_SamplingTargetDocument = (output, context) => {
-    return smithyClient.take(output, {
-        FixedRate: smithyClient.limitedParseDouble,
-        Interval: smithyClient.expectInt32,
-        ReservoirQuota: smithyClient.expectInt32,
-        ReservoirQuotaTTL: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        RuleName: smithyClient.expectString,
-        SamplingBoost: (_) => de_SamplingBoost(_),
-    });
-};
-const de_SamplingTargetDocumentList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SamplingTargetDocument(entry);
-    });
-    return retVal;
-};
-const de_Service = (output, context) => {
-    return smithyClient.take(output, {
-        AccountId: smithyClient.expectString,
-        DurationHistogram: (_) => de_Histogram(_),
-        Edges: (_) => de_EdgeList(_),
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-        Names: smithyClient._json,
-        ReferenceId: smithyClient.expectInt32,
-        ResponseTimeHistogram: (_) => de_Histogram(_),
-        Root: smithyClient.expectBoolean,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        State: smithyClient.expectString,
-        SummaryStatistics: (_) => de_ServiceStatistics(_),
-        Type: smithyClient.expectString,
-    });
-};
-const de_ServiceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Service(entry);
-    });
-    return retVal;
-};
-const de_ServiceStatistics = (output, context) => {
-    return smithyClient.take(output, {
-        ErrorStatistics: smithyClient._json,
-        FaultStatistics: smithyClient._json,
-        OkCount: smithyClient.expectLong,
-        TotalCount: smithyClient.expectLong,
-        TotalResponseTime: smithyClient.limitedParseDouble,
-    });
-};
-const de_TimeSeriesServiceStatistics = (output, context) => {
-    return smithyClient.take(output, {
-        EdgeSummaryStatistics: (_) => de_EdgeStatistics(_),
-        ResponseTimeHistogram: (_) => de_Histogram(_),
-        ServiceForecastStatistics: smithyClient._json,
-        ServiceSummaryStatistics: (_) => de_ServiceStatistics(_),
-        Timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_TimeSeriesServiceStatisticsList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_TimeSeriesServiceStatistics(entry);
-    });
-    return retVal;
-};
-const de_Trace = (output, context) => {
-    return smithyClient.take(output, {
-        Duration: smithyClient.limitedParseDouble,
-        Id: smithyClient.expectString,
-        LimitExceeded: smithyClient.expectBoolean,
-        Segments: smithyClient._json,
-    });
-};
-const de_TraceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Trace(entry);
-    });
-    return retVal;
-};
-const de_TraceSpanList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_RetrievedTrace(entry);
-    });
-    return retVal;
-};
-const de_TraceSummary = (output, context) => {
-    return smithyClient.take(output, {
-        Annotations: (_) => de_Annotations(_),
-        AvailabilityZones: smithyClient._json,
-        Duration: smithyClient.limitedParseDouble,
-        EntryPoint: smithyClient._json,
-        ErrorRootCauses: smithyClient._json,
-        FaultRootCauses: smithyClient._json,
-        HasError: smithyClient.expectBoolean,
-        HasFault: smithyClient.expectBoolean,
-        HasThrottle: smithyClient.expectBoolean,
-        Http: smithyClient._json,
-        Id: smithyClient.expectString,
-        InstanceIds: smithyClient._json,
-        IsPartial: smithyClient.expectBoolean,
-        MatchedEventTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ResourceARNs: smithyClient._json,
-        ResponseTime: smithyClient.limitedParseDouble,
-        ResponseTimeRootCauses: (_) => de_ResponseTimeRootCauses(_),
-        Revision: smithyClient.expectInt32,
-        ServiceIds: smithyClient._json,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Users: smithyClient._json,
-    });
-};
-const de_TraceSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_TraceSummary(entry);
-    });
-    return retVal;
-};
-const de_ValuesWithServiceIds = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ValueWithServiceIds(entry);
-    });
-    return retVal;
-};
-const de_ValueWithServiceIds = (output, context) => {
-    return smithyClient.take(output, {
-        AnnotationValue: (_) => de_AnnotationValue(core$1.awsExpectUnion(_)),
-        ServiceIds: smithyClient._json,
-    });
-};
-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 = "Alias";
+const _AC = "AnomalyCount";
+const _AI = "AccountId";
+const _AL = "AliasList";
+const _ARN = "ARN";
+const _AS = "AnomalousService";
+const _ASL = "AnomalousServiceList";
+const _ASP = "ActualSamplingPercentage";
+const _AT = "ApproximateTime";
+const _AV = "AnnotationValue";
+const _AZ = "AvailabilityZones";
+const _AZD = "AvailabilityZoneDetail";
+const _Al = "Aliases";
+const _An = "Annotations";
+const _At = "Attributes";
+const _BC = "BorrowCount";
+const _BCE = "BackendConnectionErrors";
+const _BGT = "BatchGetTraces";
+const _BGTR = "BatchGetTracesRequest";
+const _BGTRa = "BatchGetTracesResult";
+const _BPLC = "BypassPolicyLockoutCheck";
+const _BR = "BoostRate";
+const _BRTTL = "BoostRateTTL";
+const _BV = "BooleanValue";
+const _C = "Count";
+const _CA = "CreatedAt";
+const _CG = "CreateGroup";
+const _CGR = "CreateGroupRequest";
+const _CGRr = "CreateGroupResult";
+const _CI = "ClientImpacting";
+const _CID = "ClientID";
+const _CIl = "ClientIp";
+const _COGV = "ContainsOldGroupVersions";
+const _CRC = "ConnectionRefusedCount";
+const _CRIS = "ClientRequestImpactStatistics";
+const _CSR = "CreateSamplingRule";
+const _CSRR = "CreateSamplingRuleRequest";
+const _CSRRr = "CreateSamplingRuleResult";
+const _CTR = "CancelTraceRetrieval";
+const _CTRR = "CancelTraceRetrievalRequest";
+const _CTRRa = "CancelTraceRetrievalResult";
+const _CWM = "CooldownWindowMinutes";
+const _Ca = "Categories";
+const _Co = "Coverage";
+const _D = "Destination";
+const _DG = "DeleteGroup";
+const _DGR = "DeleteGroupRequest";
+const _DGRe = "DeleteGroupResult";
+const _DH = "DurationHistogram";
+const _DRP = "DeleteResourcePolicy";
+const _DRPR = "DeleteResourcePolicyRequest";
+const _DRPRe = "DeleteResourcePolicyResult";
+const _DSP = "DesiredSamplingPercentage";
+const _DSR = "DeleteSamplingRule";
+const _DSRR = "DeleteSamplingRuleRequest";
+const _DSRRe = "DeleteSamplingRuleResult";
+const _DTI = "DestinationTraceIds";
+const _Do = "Document";
+const _Du = "Duration";
+const _E = "Edge";
+const _EC = "EncryptionConfig";
+const _ECII = "EC2InstanceId";
+const _ECr = "ErrorCode";
+const _EL = "EdgeList";
+const _EP = "EntityPath";
+const _EPn = "EntryPoint";
+const _ERC = "ErrorRootCause";
+const _ERCE = "ErrorRootCauseEntity";
+const _ERCEP = "ErrorRootCauseEntityPath";
+const _ERCS = "ErrorRootCauseService";
+const _ERCSr = "ErrorRootCauseServices";
+const _ERCr = "ErrorRootCauses";
+const _ES = "EdgeStatistics";
+const _ESE = "EntitySelectorExpression";
+const _ESS = "EdgeSummaryStatistics";
+const _ESr = "ErrorStatistics";
+const _ET = "EndTime";
+const _ETd = "EdgeType";
+const _ETv = "EventTime";
+const _Ed = "Edges";
+const _Ex = "Exceptions";
+const _FC = "FaultCount";
+const _FCH = "FaultCountHigh";
+const _FCL = "FaultCountLow";
+const _FE = "FilterExpression";
+const _FR = "FixedRate";
+const _FRC = "FaultRootCause";
+const _FRCE = "FaultRootCauseEntity";
+const _FRCEP = "FaultRootCauseEntityPath";
+const _FRCS = "FaultRootCauseService";
+const _FRCSa = "FaultRootCauseServices";
+const _FRCa = "FaultRootCauses";
+const _FS = "FaultStatistics";
+const _FSo = "ForecastStatistics";
+const _G = "Group";
+const _GARN = "GroupARN";
+const _GEC = "GetEncryptionConfig";
+const _GECR = "GetEncryptionConfigRequest";
+const _GECRe = "GetEncryptionConfigResult";
+const _GG = "GetGroup";
+const _GGR = "GetGroupRequest";
+const _GGRe = "GetGroupResult";
+const _GGRet = "GetGroupsRequest";
+const _GGRetr = "GetGroupsResult";
+const _GGe = "GetGroups";
+const _GI = "GetInsight";
+const _GIE = "GetInsightEvents";
+const _GIER = "GetInsightEventsRequest";
+const _GIERe = "GetInsightEventsResult";
+const _GIIG = "GetInsightImpactGraph";
+const _GIIGR = "GetInsightImpactGraphRequest";
+const _GIIGRe = "GetInsightImpactGraphResult";
+const _GIR = "GetInsightRequest";
+const _GIRR = "GetIndexingRulesRequest";
+const _GIRRe = "GetIndexingRulesResult";
+const _GIRe = "GetInsightResult";
+const _GIRet = "GetIndexingRules";
+const _GIS = "GetInsightSummaries";
+const _GISR = "GetInsightSummariesRequest";
+const _GISRe = "GetInsightSummariesResult";
+const _GL = "GraphLink";
+const _GN = "GroupName";
+const _GRTG = "GetRetrievedTracesGraph";
+const _GRTGR = "GetRetrievedTracesGraphRequest";
+const _GRTGRe = "GetRetrievedTracesGraphResult";
+const _GS = "GroupSummary";
+const _GSG = "GetServiceGraph";
+const _GSGR = "GetServiceGraphRequest";
+const _GSGRe = "GetServiceGraphResult";
+const _GSL = "GroupSummaryList";
+const _GSR = "GetSamplingRules";
+const _GSRR = "GetSamplingRulesRequest";
+const _GSRRe = "GetSamplingRulesResult";
+const _GSSS = "GetSamplingStatisticSummaries";
+const _GSSSR = "GetSamplingStatisticSummariesRequest";
+const _GSSSRe = "GetSamplingStatisticSummariesResult";
+const _GST = "GetSamplingTargets";
+const _GSTR = "GetSamplingTargetsRequest";
+const _GSTRe = "GetSamplingTargetsResult";
+const _GTG = "GetTraceGraph";
+const _GTGR = "GetTraceGraphRequest";
+const _GTGRe = "GetTraceGraphResult";
+const _GTS = "GetTraceSummaries";
+const _GTSD = "GetTraceSegmentDestination";
+const _GTSDR = "GetTraceSegmentDestinationRequest";
+const _GTSDRe = "GetTraceSegmentDestinationResult";
+const _GTSR = "GetTraceSummariesRequest";
+const _GTSRe = "GetTraceSummariesResult";
+const _GTSSS = "GetTimeSeriesServiceStatistics";
+const _GTSSSR = "GetTimeSeriesServiceStatisticsRequest";
+const _GTSSSRe = "GetTimeSeriesServiceStatisticsResult";
+const _Gr = "Groups";
+const _H = "Http";
+const _HE = "HistogramEntry";
+const _HEa = "HasError";
+const _HF = "HasFault";
+const _HM = "HttpMethod";
+const _HS = "HttpStatus";
+const _HT = "HasThrottle";
+const _HTTPCXXC = "HTTPCode4XXCount";
+const _HTTPCXXCo = "HTTPCode5XXCount";
+const _HTTPM = "HTTPMethod";
+const _HURL = "HttpURL";
+const _Hi = "Histogram";
+const _Ho = "Hostname";
+const _Hos = "Host";
+const _I = "Inferred";
+const _IC = "InsightsConfiguration";
+const _IE = "InsightEvents";
+const _IEL = "InsightEventList";
+const _IEn = "InsightEvent";
+const _IEns = "InsightsEnabled";
+const _II = "InsightId";
+const _IID = "InstanceIdDetail";
+const _IIGE = "InsightImpactGraphEdge";
+const _IIGEL = "InsightImpactGraphEdgeList";
+const _IIGS = "InsightImpactGraphService";
+const _IIGSL = "InsightImpactGraphServiceList";
+const _IIn = "InstanceIds";
+const _IP = "IsPartial";
+const _IPRIE = "InvalidPolicyRevisionIdException";
+const _IR = "IndexingRules";
+const _IRE = "InvalidRequestException";
+const _IRL = "IndexingRuleList";
+const _IRV = "IndexingRuleValue";
+const _IRVU = "IndexingRuleValueUpdate";
+const _IRn = "IndexingRule";
+const _IS = "InsightSummaries";
+const _ISL = "InsightSummaryList";
+const _ISn = "InsightSummary";
+const _Id = "Id";
+const _In = "Insight";
+const _Int = "Interval";
+const _K = "Key";
+const _KI = "KeyId";
+const _L = "Links";
+const _LE = "LimitExceeded";
+const _LL = "LinksList";
+const _LPE = "LockoutPreventionException";
+const _LRM = "LastRuleModification";
+const _LRP = "ListResourcePolicies";
+const _LRPR = "ListResourcePoliciesRequest";
+const _LRPRi = "ListResourcePoliciesResult";
+const _LRT = "ListRetrievedTraces";
+const _LRTR = "ListRetrievedTracesRequest";
+const _LRTRi = "ListRetrievedTracesResult";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LUT = "LastUpdateTime";
+const _LUTa = "LastUpdatedTime";
+const _M = "Message";
+const _MA = "ModifiedAt";
+const _MET = "MatchedEventTime";
+const _MPDE = "MalformedPolicyDocumentException";
+const _MR = "MaxResults";
+const _MRa = "MaxRate";
+const _N = "Name";
+const _NE = "NotificationsEnabled";
+const _NT = "NextToken";
+const _NV = "NumberValue";
+const _Na = "Names";
+const _OC = "OtherCount";
+const _OCk = "OkCount";
+const _P = "Period";
+const _PCLEE = "PolicyCountLimitExceededException";
+const _PD = "PolicyDocument";
+const _PEC = "PutEncryptionConfig";
+const _PECR = "PutEncryptionConfigRequest";
+const _PECRu = "PutEncryptionConfigResult";
+const _PN = "PolicyName";
+const _PRI = "PolicyRevisionId";
+const _PRP = "PutResourcePolicy";
+const _PRPR = "PutResourcePolicyRequest";
+const _PRPRu = "PutResourcePolicyResult";
+const _PRV = "ProbabilisticRuleValue";
+const _PRVU = "ProbabilisticRuleValueUpdate";
+const _PSLEE = "PolicySizeLimitExceededException";
+const _PTR = "PutTelemetryRecords";
+const _PTRR = "PutTelemetryRecordsRequest";
+const _PTRRu = "PutTelemetryRecordsResult";
+const _PTS = "PutTraceSegments";
+const _PTSR = "PutTraceSegmentsRequest";
+const _PTSRu = "PutTraceSegmentsResult";
+const _Pr = "Priority";
+const _Pro = "Probabilistic";
+const _R = "Remote";
+const _RARN = "RuleARN";
+const _RARND = "ResourceARNDetail";
+const _RARNe = "ResourceARN";
+const _RARNes = "ResourceARNs";
+const _RC = "RequestCount";
+const _RCE = "RootCauseException";
+const _RCEo = "RootCauseExceptions";
+const _RCSI = "RootCauseServiceId";
+const _RCSRIS = "RootCauseServiceRequestImpactStatistics";
+const _REAH = "ReceivedEventAgeHistogram";
+const _RI = "ReferenceId";
+const _RIS = "RequestImpactStatistics";
+const _RLEE = "RuleLimitExceededException";
+const _RN = "RuleName";
+const _RNFE = "ResourceNotFoundException";
+const _RNe = "ResourceName";
+const _RP = "ResourcePolicies";
+const _RPL = "ResourcePolicyList";
+const _RPe = "ResourcePolicy";
+const _RQ = "ReservoirQuota";
+const _RQTTL = "ReservoirQuotaTTL";
+const _RS = "RetrievalStatus";
+const _RSL = "RetrievedServicesList";
+const _RSe = "RetrievedService";
+const _RSes = "ReservoirSize";
+const _RT = "RetrievalToken";
+const _RTH = "ResponseTimeHistogram";
+const _RTRC = "ResponseTimeRootCause";
+const _RTRCE = "ResponseTimeRootCauseEntity";
+const _RTRCEP = "ResponseTimeRootCauseEntityPath";
+const _RTRCS = "ResponseTimeRootCauseService";
+const _RTRCSe = "ResponseTimeRootCauseServices";
+const _RTRCe = "ResponseTimeRootCauses";
+const _RTe = "ReferenceType";
+const _RTes = "ResponseTime";
+const _RTet = "RetrievedTrace";
+const _Re = "Revision";
+const _Ro = "Root";
+const _Ru = "Rule";
+const _S = "Status";
+const _SAC = "SampledAnomalyCount";
+const _SB = "SamplingBoost";
+const _SBSD = "SamplingBoostStatisticsDocuments";
+const _SBSDL = "SamplingBoostStatisticsDocumentList";
+const _SBSDa = "SamplingBoostStatisticsDocument";
+const _SC = "SampledCount";
+const _SFS = "ServiceForecastStatistics";
+const _SGET = "ServiceGraphEndTime";
+const _SGST = "ServiceGraphStartTime";
+const _SI = "ServiceId";
+const _SIe = "ServiceIds";
+const _SL = "SegmentList";
+const _SLe = "ServiceList";
+const _SLp = "SpanList";
+const _SN = "ServiceName";
+const _SR = "SamplingRule";
+const _SRB = "SamplingRateBoost";
+const _SRC = "SegmentsReceivedCount";
+const _SRCe = "SegmentsRejectedCount";
+const _SRR = "SamplingRuleRecord";
+const _SRRL = "SamplingRuleRecordList";
+const _SRRa = "SamplingRuleRecords";
+const _SRU = "SamplingRuleUpdate";
+const _SS = "SummaryStatistics";
+const _SSC = "SegmentsSentCount";
+const _SSCe = "SegmentsSpilloverCount";
+const _SSD = "SamplingStatisticsDocuments";
+const _SSDL = "SamplingStatisticsDocumentList";
+const _SSDa = "SamplingStatisticsDocument";
+const _SSS = "SamplingStatisticSummaries";
+const _SSSL = "SamplingStatisticSummaryList";
+const _SSSa = "SamplingStatisticSummary";
+const _SSSe = "ServiceSummaryStatistics";
+const _SSa = "SamplingStrategy";
+const _SSe = "ServiceStatistics";
+const _ST = "StartTime";
+const _STD = "SamplingTargetDocuments";
+const _STDL = "SamplingTargetDocumentList";
+const _STDa = "SamplingTargetDocument";
+const _STI = "SourceTraceId";
+const _STR = "StartTraceRetrieval";
+const _STRR = "StartTraceRetrievalRequest";
+const _STRRt = "StartTraceRetrievalResult";
+const _STe = "ServiceType";
+const _SV = "StringValue";
+const _Sa = "Sampling";
+const _Se = "Services";
+const _Seg = "Segment";
+const _Segm = "Segments";
+const _Ser = "Service";
+const _Sp = "Spans";
+const _Spa = "Span";
+const _St = "States";
+const _Sta = "State";
+const _Su = "Summary";
+const _T = "Type";
+const _TAS = "TopAnomalousServices";
+const _TAZ = "TraceAvailabilityZones";
+const _TC = "TimeoutCount";
+const _TCh = "ThrottleCount";
+const _TCo = "TotalCount";
+const _TE = "ThrottledException";
+const _TF = "TraceFormat";
+const _TI = "TraceIds";
+const _TII = "TraceInstanceIds";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TLr = "TraceList";
+const _TMTE = "TooManyTagsException";
+const _TPC = "TracesProcessedCount";
+const _TR = "TelemetryRecords";
+const _TRARN = "TraceResourceARNs";
+const _TRL = "TelemetryRecordList";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TRT = "TotalResponseTime";
+const _TRTi = "TimeRangeType";
+const _TRa = "TagResource";
+const _TRe = "TelemetryRecord";
+const _TS = "TraceSummaries";
+const _TSD = "TraceSegmentDocuments";
+const _TSL = "TraceSpanList";
+const _TSLr = "TraceSummaryList";
+const _TSSS = "TimeSeriesServiceStatistics";
+const _TSSSL = "TimeSeriesServiceStatisticsList";
+const _TSr = "TraceSummary";
+const _TU = "TraceUser";
+const _TUr = "TraceUsers";
+const _Ta = "Tags";
+const _Tag = "Tag";
+const _Ti = "Timestamp";
+const _Tr = "Traces";
+const _Tra = "Trace";
+const _U = "Users";
+const _UA = "UserAgent";
+const _UBS = "UnprocessedBoostStatistics";
+const _UG = "UpdateGroup";
+const _UGR = "UpdateGroupRequest";
+const _UGRp = "UpdateGroupResult";
+const _UHC = "UnknownHostCount";
+const _UIR = "UpdateIndexingRule";
+const _UIRR = "UpdateIndexingRuleRequest";
+const _UIRRp = "UpdateIndexingRuleResult";
+const _UN = "UserName";
+const _UR = "UntagResource";
+const _URLP = "URLPath";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _US = "UnprocessedStatistics";
+const _USL = "UnprocessedStatisticsList";
+const _USR = "UpdateSamplingRule";
+const _USRR = "UpdateSamplingRuleRequest";
+const _USRRp = "UpdateSamplingRuleResult";
+const _UTI = "UnprocessedTraceIds";
+const _UTS = "UnprocessedTraceSegments";
+const _UTSD = "UpdateTraceSegmentDestination";
+const _UTSDR = "UpdateTraceSegmentDestinationRequest";
+const _UTSDRp = "UpdateTraceSegmentDestinationResult";
+const _UTSL = "UnprocessedTraceSegmentList";
+const _UTSn = "UnprocessedTraceSegment";
+const _V = "Value";
+const _VWSI = "ValueWithServiceIds";
+const _VWSIa = "ValuesWithServiceIds";
+const _Ve = "Version";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.xray";
+const n0 = "com.amazonaws.xray";
+var Alias = [3, n0, _A, 0, [_N, _Na, _T], [0, 64 | 0, 0]];
+var AnomalousService = [3, n0, _AS, 0, [_SI], [() => ServiceId]];
+var AvailabilityZoneDetail = [3, n0, _AZD, 0, [_N], [0]];
+var BackendConnectionErrors = [
+    3,
+    n0,
+    _BCE,
+    0,
+    [_TC, _CRC, _HTTPCXXC, _HTTPCXXCo, _UHC, _OC],
+    [1, 1, 1, 1, 1, 1],
+];
+var BatchGetTracesRequest = [3, n0, _BGTR, 0, [_TI, _NT], [64 | 0, 0]];
+var BatchGetTracesResult = [
+    3,
+    n0,
+    _BGTRa,
+    0,
+    [_Tr, _UTI, _NT],
+    [() => TraceList, 64 | 0, 0],
+];
+var CancelTraceRetrievalRequest = [3, n0, _CTRR, 0, [_RT], [0]];
+var CancelTraceRetrievalResult = [3, n0, _CTRRa, 0, [], []];
+var CreateGroupRequest = [
+    3,
+    n0,
+    _CGR,
+    0,
+    [_GN, _FE, _IC, _Ta],
+    [0, 0, () => InsightsConfiguration, () => TagList],
+];
+var CreateGroupResult = [3, n0, _CGRr, 0, [_G], [() => Group]];
+var CreateSamplingRuleRequest = [
+    3,
+    n0,
+    _CSRR,
+    0,
+    [_SR, _Ta],
+    [() => SamplingRule, () => TagList],
+];
+var CreateSamplingRuleResult = [3, n0, _CSRRr, 0, [_SRR], [() => SamplingRuleRecord]];
+var DeleteGroupRequest = [3, n0, _DGR, 0, [_GN, _GARN], [0, 0]];
+var DeleteGroupResult = [3, n0, _DGRe, 0, [], []];
+var DeleteResourcePolicyRequest = [3, n0, _DRPR, 0, [_PN, _PRI], [0, 0]];
+var DeleteResourcePolicyResult = [3, n0, _DRPRe, 0, [], []];
+var DeleteSamplingRuleRequest = [3, n0, _DSRR, 0, [_RN, _RARN], [0, 0]];
+var DeleteSamplingRuleResult = [3, n0, _DSRRe, 0, [_SRR], [() => SamplingRuleRecord]];
+var Edge = [
+    3,
+    n0,
+    _E,
+    0,
+    [_RI, _ST, _ET, _SS, _RTH, _Al, _ETd, _REAH],
+    [1, 4, 4, () => EdgeStatistics, () => Histogram, () => AliasList, 0, () => Histogram],
+];
+var EdgeStatistics = [
+    3,
+    n0,
+    _ES,
+    0,
+    [_OCk, _ESr, _FS, _TCo, _TRT],
+    [1, () => ErrorStatistics, () => FaultStatistics, 1, 1],
+];
+var EncryptionConfig = [3, n0, _EC, 0, [_KI, _S, _T], [0, 0, 0]];
+var ErrorRootCause = [3, n0, _ERC, 0, [_Se, _CI], [() => ErrorRootCauseServices, 2]];
+var ErrorRootCauseEntity = [
+    3,
+    n0,
+    _ERCE,
+    0,
+    [_N, _Ex, _R],
+    [0, () => RootCauseExceptions, 2],
+];
+var ErrorRootCauseService = [
+    3,
+    n0,
+    _ERCS,
+    0,
+    [_N, _Na, _T, _AI, _EP, _I],
+    [0, 64 | 0, 0, 0, () => ErrorRootCauseEntityPath, 2],
+];
+var ErrorStatistics = [3, n0, _ESr, 0, [_TCh, _OC, _TCo], [1, 1, 1]];
+var FaultRootCause = [3, n0, _FRC, 0, [_Se, _CI], [() => FaultRootCauseServices, 2]];
+var FaultRootCauseEntity = [
+    3,
+    n0,
+    _FRCE,
+    0,
+    [_N, _Ex, _R],
+    [0, () => RootCauseExceptions, 2],
+];
+var FaultRootCauseService = [
+    3,
+    n0,
+    _FRCS,
+    0,
+    [_N, _Na, _T, _AI, _EP, _I],
+    [0, 64 | 0, 0, 0, () => FaultRootCauseEntityPath, 2],
+];
+var FaultStatistics = [3, n0, _FS, 0, [_OC, _TCo], [1, 1]];
+var ForecastStatistics = [3, n0, _FSo, 0, [_FCH, _FCL], [1, 1]];
+var GetEncryptionConfigRequest = [3, n0, _GECR, 0, [], []];
+var GetEncryptionConfigResult = [3, n0, _GECRe, 0, [_EC], [() => EncryptionConfig]];
+var GetGroupRequest = [3, n0, _GGR, 0, [_GN, _GARN], [0, 0]];
+var GetGroupResult = [3, n0, _GGRe, 0, [_G], [() => Group]];
+var GetGroupsRequest = [3, n0, _GGRet, 0, [_NT], [0]];
+var GetGroupsResult = [3, n0, _GGRetr, 0, [_Gr, _NT], [() => GroupSummaryList, 0]];
+var GetIndexingRulesRequest = [3, n0, _GIRR, 0, [_NT], [0]];
+var GetIndexingRulesResult = [3, n0, _GIRRe, 0, [_IR, _NT], [() => IndexingRuleList, 0]];
+var GetInsightEventsRequest = [3, n0, _GIER, 0, [_II, _MR, _NT], [0, 1, 0]];
+var GetInsightEventsResult = [3, n0, _GIERe, 0, [_IE, _NT], [() => InsightEventList, 0]];
+var GetInsightImpactGraphRequest = [3, n0, _GIIGR, 0, [_II, _ST, _ET, _NT], [0, 4, 4, 0]];
+var GetInsightImpactGraphResult = [
+    3,
+    n0,
+    _GIIGRe,
+    0,
+    [_II, _ST, _ET, _SGST, _SGET, _Se, _NT],
+    [0, 4, 4, 4, 4, () => InsightImpactGraphServiceList, 0],
+];
+var GetInsightRequest = [3, n0, _GIR, 0, [_II], [0]];
+var GetInsightResult = [3, n0, _GIRe, 0, [_In], [() => Insight]];
+var GetInsightSummariesRequest = [
+    3,
+    n0,
+    _GISR,
+    0,
+    [_St, _GARN, _GN, _ST, _ET, _MR, _NT],
+    [64 | 0, 0, 0, 4, 4, 1, 0],
+];
+var GetInsightSummariesResult = [
+    3,
+    n0,
+    _GISRe,
+    0,
+    [_IS, _NT],
+    [() => InsightSummaryList, 0],
+];
+var GetRetrievedTracesGraphRequest = [3, n0, _GRTGR, 0, [_RT, _NT], [0, 0]];
+var GetRetrievedTracesGraphResult = [
+    3,
+    n0,
+    _GRTGRe,
+    0,
+    [_RS, _Se, _NT],
+    [0, () => RetrievedServicesList, 0],
+];
+var GetSamplingRulesRequest = [3, n0, _GSRR, 0, [_NT], [0]];
+var GetSamplingRulesResult = [
+    3,
+    n0,
+    _GSRRe,
+    0,
+    [_SRRa, _NT],
+    [() => SamplingRuleRecordList, 0],
+];
+var GetSamplingStatisticSummariesRequest = [3, n0, _GSSSR, 0, [_NT], [0]];
+var GetSamplingStatisticSummariesResult = [
+    3,
+    n0,
+    _GSSSRe,
+    0,
+    [_SSS, _NT],
+    [() => SamplingStatisticSummaryList, 0],
+];
+var GetSamplingTargetsRequest = [
+    3,
+    n0,
+    _GSTR,
+    0,
+    [_SSD, _SBSD],
+    [() => SamplingStatisticsDocumentList, () => SamplingBoostStatisticsDocumentList],
+];
+var GetSamplingTargetsResult = [
+    3,
+    n0,
+    _GSTRe,
+    0,
+    [_STD, _LRM, _US, _UBS],
+    [() => SamplingTargetDocumentList, 4, () => UnprocessedStatisticsList, () => UnprocessedStatisticsList],
+];
+var GetServiceGraphRequest = [
+    3,
+    n0,
+    _GSGR,
+    0,
+    [_ST, _ET, _GN, _GARN, _NT],
+    [4, 4, 0, 0, 0],
+];
+var GetServiceGraphResult = [
+    3,
+    n0,
+    _GSGRe,
+    0,
+    [_ST, _ET, _Se, _COGV, _NT],
+    [4, 4, () => ServiceList, 2, 0],
+];
+var GetTimeSeriesServiceStatisticsRequest = [
+    3,
+    n0,
+    _GTSSSR,
+    0,
+    [_ST, _ET, _GN, _GARN, _ESE, _P, _FSo, _NT],
+    [4, 4, 0, 0, 0, 1, 2, 0],
+];
+var GetTimeSeriesServiceStatisticsResult = [
+    3,
+    n0,
+    _GTSSSRe,
+    0,
+    [_TSSS, _COGV, _NT],
+    [() => TimeSeriesServiceStatisticsList, 2, 0],
+];
+var GetTraceGraphRequest = [3, n0, _GTGR, 0, [_TI, _NT], [64 | 0, 0]];
+var GetTraceGraphResult = [3, n0, _GTGRe, 0, [_Se, _NT], [() => ServiceList, 0]];
+var GetTraceSegmentDestinationRequest = [3, n0, _GTSDR, 0, [], []];
+var GetTraceSegmentDestinationResult = [3, n0, _GTSDRe, 0, [_D, _S], [0, 0]];
+var GetTraceSummariesRequest = [
+    3,
+    n0,
+    _GTSR,
+    0,
+    [_ST, _ET, _TRTi, _Sa, _SSa, _FE, _NT],
+    [4, 4, 0, 2, () => SamplingStrategy, 0, 0],
+];
+var GetTraceSummariesResult = [
+    3,
+    n0,
+    _GTSRe,
+    0,
+    [_TS, _AT, _TPC, _NT],
+    [() => TraceSummaryList, 4, 1, 0],
+];
+var GraphLink = [3, n0, _GL, 0, [_RTe, _STI, _DTI], [0, 0, 64 | 0]];
+var Group = [
+    3,
+    n0,
+    _G,
+    0,
+    [_GN, _GARN, _FE, _IC],
+    [0, 0, 0, () => InsightsConfiguration],
+];
+var GroupSummary = [
+    3,
+    n0,
+    _GS,
+    0,
+    [_GN, _GARN, _FE, _IC],
+    [0, 0, 0, () => InsightsConfiguration],
+];
+var HistogramEntry = [3, n0, _HE, 0, [_V, _C], [1, 1]];
+var Http = [3, n0, _H, 0, [_HURL, _HS, _HM, _UA, _CIl], [0, 1, 0, 0, 0]];
+var IndexingRule = [3, n0, _IRn, 0, [_N, _MA, _Ru], [0, 4, () => IndexingRuleValue]];
+var Insight = [
+    3,
+    n0,
+    _In,
+    0,
+    [_II, _GARN, _GN, _RCSI, _Ca, _Sta, _ST, _ET, _Su, _CRIS, _RCSRIS, _TAS],
+    [
+        0,
+        0,
+        0,
+        () => ServiceId,
+        64 | 0,
+        0,
+        4,
+        4,
+        0,
+        () => RequestImpactStatistics,
+        () => RequestImpactStatistics,
+        () => AnomalousServiceList,
+    ],
+];
+var InsightEvent = [
+    3,
+    n0,
+    _IEn,
+    0,
+    [_Su, _ETv, _CRIS, _RCSRIS, _TAS],
+    [0, 4, () => RequestImpactStatistics, () => RequestImpactStatistics, () => AnomalousServiceList],
+];
+var InsightImpactGraphEdge = [3, n0, _IIGE, 0, [_RI], [1]];
+var InsightImpactGraphService = [
+    3,
+    n0,
+    _IIGS,
+    0,
+    [_RI, _T, _N, _Na, _AI, _Ed],
+    [1, 0, 0, 64 | 0, 0, () => InsightImpactGraphEdgeList],
+];
+var InsightsConfiguration = [3, n0, _IC, 0, [_IEns, _NE], [2, 2]];
+var InsightSummary = [
+    3,
+    n0,
+    _ISn,
+    0,
+    [_II, _GARN, _GN, _RCSI, _Ca, _Sta, _ST, _ET, _Su, _CRIS, _RCSRIS, _TAS, _LUT],
+    [
+        0,
+        0,
+        0,
+        () => ServiceId,
+        64 | 0,
+        0,
+        4,
+        4,
+        0,
+        () => RequestImpactStatistics,
+        () => RequestImpactStatistics,
+        () => AnomalousServiceList,
+        4,
+    ],
+];
+var InstanceIdDetail = [3, n0, _IID, 0, [_Id], [0]];
+var InvalidPolicyRevisionIdException = [
+    -3,
+    n0,
+    _IPRIE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidPolicyRevisionIdException, InvalidPolicyRevisionIdException$1);
+var InvalidRequestException = [
+    -3,
+    n0,
+    _IRE,
+    {
+        [_e]: _c,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidRequestException, InvalidRequestException$1);
+var ListResourcePoliciesRequest = [3, n0, _LRPR, 0, [_NT], [0]];
+var ListResourcePoliciesResult = [
+    3,
+    n0,
+    _LRPRi,
+    0,
+    [_RP, _NT],
+    [() => ResourcePolicyList, 0],
+];
+var ListRetrievedTracesRequest = [3, n0, _LRTR, 0, [_RT, _TF, _NT], [0, 0, 0]];
+var ListRetrievedTracesResult = [
+    3,
+    n0,
+    _LRTRi,
+    0,
+    [_RS, _TF, _Tr, _NT],
+    [0, 0, () => TraceSpanList, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RARNe, _NT], [0, 0]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_Ta, _NT], [() => TagList, 0]];
+var LockoutPreventionException = [
+    -3,
+    n0,
+    _LPE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LockoutPreventionException, LockoutPreventionException$1);
+var MalformedPolicyDocumentException = [
+    -3,
+    n0,
+    _MPDE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(MalformedPolicyDocumentException, MalformedPolicyDocumentException$1);
+var PolicyCountLimitExceededException = [
+    -3,
+    n0,
+    _PCLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(PolicyCountLimitExceededException, PolicyCountLimitExceededException$1);
+var PolicySizeLimitExceededException = [
+    -3,
+    n0,
+    _PSLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(PolicySizeLimitExceededException, PolicySizeLimitExceededException$1);
+var ProbabilisticRuleValue = [3, n0, _PRV, 0, [_DSP, _ASP], [1, 1]];
+var ProbabilisticRuleValueUpdate = [3, n0, _PRVU, 0, [_DSP], [1]];
+var PutEncryptionConfigRequest = [3, n0, _PECR, 0, [_KI, _T], [0, 0]];
+var PutEncryptionConfigResult = [3, n0, _PECRu, 0, [_EC], [() => EncryptionConfig]];
+var PutResourcePolicyRequest = [3, n0, _PRPR, 0, [_PN, _PD, _PRI, _BPLC], [0, 0, 0, 2]];
+var PutResourcePolicyResult = [3, n0, _PRPRu, 0, [_RPe], [() => ResourcePolicy]];
+var PutTelemetryRecordsRequest = [
+    3,
+    n0,
+    _PTRR,
+    0,
+    [_TR, _ECII, _Ho, _RARNe],
+    [() => TelemetryRecordList, 0, 0, 0],
+];
+var PutTelemetryRecordsResult = [3, n0, _PTRRu, 0, [], []];
+var PutTraceSegmentsRequest = [3, n0, _PTSR, 0, [_TSD], [64 | 0]];
+var PutTraceSegmentsResult = [
+    3,
+    n0,
+    _PTSRu,
+    0,
+    [_UTS],
+    [() => UnprocessedTraceSegmentList],
+];
+var RequestImpactStatistics = [3, n0, _RIS, 0, [_FC, _OCk, _TCo], [1, 1, 1]];
+var ResourceARNDetail = [3, n0, _RARND, 0, [_ARN], [0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M, _RNe],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ResourcePolicy = [3, n0, _RPe, 0, [_PN, _PD, _PRI, _LUTa], [0, 0, 0, 4]];
+var ResponseTimeRootCause = [
+    3,
+    n0,
+    _RTRC,
+    0,
+    [_Se, _CI],
+    [() => ResponseTimeRootCauseServices, 2],
+];
+var ResponseTimeRootCauseEntity = [3, n0, _RTRCE, 0, [_N, _Co, _R], [0, 1, 2]];
+var ResponseTimeRootCauseService = [
+    3,
+    n0,
+    _RTRCS,
+    0,
+    [_N, _Na, _T, _AI, _EP, _I],
+    [0, 64 | 0, 0, 0, () => ResponseTimeRootCauseEntityPath, 2],
+];
+var RetrievedService = [3, n0, _RSe, 0, [_Ser, _L], [() => Service, () => LinksList]];
+var RetrievedTrace = [3, n0, _RTet, 0, [_Id, _Du, _Sp], [0, 1, () => SpanList]];
+var RootCauseException = [3, n0, _RCE, 0, [_N, _M], [0, 0]];
+var RuleLimitExceededException = [
+    -3,
+    n0,
+    _RLEE,
+    {
+        [_e]: _c,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RuleLimitExceededException, RuleLimitExceededException$1);
+var SamplingBoost = [3, n0, _SB, 0, [_BR, _BRTTL], [1, 4]];
+var SamplingBoostStatisticsDocument = [
+    3,
+    n0,
+    _SBSDa,
+    0,
+    [_RN, _SN, _Ti, _AC, _TCo, _SAC],
+    [0, 0, 4, 1, 1, 1],
+];
+var SamplingRateBoost = [3, n0, _SRB, 0, [_MRa, _CWM], [1, 1]];
+var SamplingRule = [
+    3,
+    n0,
+    _SR,
+    0,
+    [_RN, _RARN, _RARNe, _Pr, _FR, _RSes, _SN, _STe, _Hos, _HTTPM, _URLP, _Ve, _At, _SRB],
+    [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 128 | 0, () => SamplingRateBoost],
+];
+var SamplingRuleRecord = [3, n0, _SRR, 0, [_SR, _CA, _MA], [() => SamplingRule, 4, 4]];
+var SamplingRuleUpdate = [
+    3,
+    n0,
+    _SRU,
+    0,
+    [_RN, _RARN, _RARNe, _Pr, _FR, _RSes, _Hos, _SN, _STe, _HTTPM, _URLP, _At, _SRB],
+    [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 128 | 0, () => SamplingRateBoost],
+];
+var SamplingStatisticsDocument = [
+    3,
+    n0,
+    _SSDa,
+    0,
+    [_RN, _CID, _Ti, _RC, _SC, _BC],
+    [0, 0, 4, 1, 1, 1],
+];
+var SamplingStatisticSummary = [
+    3,
+    n0,
+    _SSSa,
+    0,
+    [_RN, _Ti, _RC, _BC, _SC],
+    [0, 4, 1, 1, 1],
+];
+var SamplingStrategy = [3, n0, _SSa, 0, [_N, _V], [0, 1]];
+var SamplingTargetDocument = [
+    3,
+    n0,
+    _STDa,
+    0,
+    [_RN, _FR, _RQ, _RQTTL, _Int, _SB],
+    [0, 1, 1, 4, 1, () => SamplingBoost],
+];
+var Segment = [3, n0, _Seg, 0, [_Id, _Do], [0, 0]];
+var Service = [
+    3,
+    n0,
+    _Ser,
+    0,
+    [_RI, _N, _Na, _Ro, _AI, _T, _Sta, _ST, _ET, _Ed, _SS, _DH, _RTH],
+    [1, 0, 64 | 0, 2, 0, 0, 0, 4, 4, () => EdgeList, () => ServiceStatistics, () => Histogram, () => Histogram],
+];
+var ServiceId = [3, n0, _SI, 0, [_N, _Na, _AI, _T], [0, 64 | 0, 0, 0]];
+var ServiceStatistics = [
+    3,
+    n0,
+    _SSe,
+    0,
+    [_OCk, _ESr, _FS, _TCo, _TRT],
+    [1, () => ErrorStatistics, () => FaultStatistics, 1, 1],
+];
+var Span = [3, n0, _Spa, 0, [_Id, _Do], [0, 0]];
+var StartTraceRetrievalRequest = [3, n0, _STRR, 0, [_TI, _ST, _ET], [64 | 0, 4, 4]];
+var StartTraceRetrievalResult = [3, n0, _STRRt, 0, [_RT], [0]];
+var Tag = [3, n0, _Tag, 0, [_K, _V], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RARNe, _Ta], [0, () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TelemetryRecord = [
+    3,
+    n0,
+    _TRe,
+    0,
+    [_Ti, _SRC, _SSC, _SSCe, _SRCe, _BCE],
+    [4, 1, 1, 1, 1, () => BackendConnectionErrors],
+];
+var ThrottledException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottledException, ThrottledException$1);
+var TimeSeriesServiceStatistics = [
+    3,
+    n0,
+    _TSSS,
+    0,
+    [_Ti, _ESS, _SSSe, _SFS, _RTH],
+    [4, () => EdgeStatistics, () => ServiceStatistics, () => ForecastStatistics, () => Histogram],
+];
+var TooManyTagsException = [
+    -3,
+    n0,
+    _TMTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _RNe],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyTagsException, TooManyTagsException$1);
+var Trace = [3, n0, _Tra, 0, [_Id, _Du, _LE, _Segm], [0, 1, 2, () => SegmentList]];
+var TraceSummary = [
+    3,
+    n0,
+    _TSr,
+    0,
+    [
+        _Id,
+        _ST,
+        _Du,
+        _RTes,
+        _HF,
+        _HEa,
+        _HT,
+        _IP,
+        _H,
+        _An,
+        _U,
+        _SIe,
+        _RARNes,
+        _IIn,
+        _AZ,
+        _EPn,
+        _FRCa,
+        _ERCr,
+        _RTRCe,
+        _Re,
+        _MET,
+    ],
+    [
+        0,
+        4,
+        1,
+        1,
+        2,
+        2,
+        2,
+        2,
+        () => Http,
+        () => Annotations,
+        () => TraceUsers,
+        () => ServiceIds,
+        () => TraceResourceARNs,
+        () => TraceInstanceIds,
+        () => TraceAvailabilityZones,
+        () => ServiceId,
+        () => FaultRootCauses,
+        () => ErrorRootCauses,
+        () => ResponseTimeRootCauses,
+        1,
+        4,
+    ],
+];
+var TraceUser = [3, n0, _TU, 0, [_UN, _SIe], [0, () => ServiceIds]];
+var UnprocessedStatistics = [3, n0, _US, 0, [_RN, _ECr, _M], [0, 0, 0]];
+var UnprocessedTraceSegment = [3, n0, _UTSn, 0, [_Id, _ECr, _M], [0, 0, 0]];
+var UntagResourceRequest = [3, n0, _URR, 0, [_RARNe, _TK], [0, 64 | 0]];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateGroupRequest = [
+    3,
+    n0,
+    _UGR,
+    0,
+    [_GN, _GARN, _FE, _IC],
+    [0, 0, 0, () => InsightsConfiguration],
+];
+var UpdateGroupResult = [3, n0, _UGRp, 0, [_G], [() => Group]];
+var UpdateIndexingRuleRequest = [
+    3,
+    n0,
+    _UIRR,
+    0,
+    [_N, _Ru],
+    [0, () => IndexingRuleValueUpdate],
+];
+var UpdateIndexingRuleResult = [3, n0, _UIRRp, 0, [_IRn], [() => IndexingRule]];
+var UpdateSamplingRuleRequest = [3, n0, _USRR, 0, [_SRU], [() => SamplingRuleUpdate]];
+var UpdateSamplingRuleResult = [3, n0, _USRRp, 0, [_SRR], [() => SamplingRuleRecord]];
+var UpdateTraceSegmentDestinationRequest = [3, n0, _UTSDR, 0, [_D], [0]];
+var UpdateTraceSegmentDestinationResult = [3, n0, _UTSDRp, 0, [_D, _S], [0, 0]];
+var ValueWithServiceIds = [
+    3,
+    n0,
+    _VWSI,
+    0,
+    [_AV, _SIe],
+    [() => AnnotationValue, () => ServiceIds],
+];
+var XRayServiceException = [-3, _s, "XRayServiceException", 0, [], []];
+schema.TypeRegistry.for(_s).registerError(XRayServiceException, XRayServiceException$1);
+var AliasList = [1, n0, _AL, 0, () => Alias];
+var AnomalousServiceList = [1, n0, _ASL, 0, () => AnomalousService];
+var EdgeList = [1, n0, _EL, 0, () => Edge];
+var ErrorRootCauseEntityPath = [1, n0, _ERCEP, 0, () => ErrorRootCauseEntity];
+var ErrorRootCauses = [1, n0, _ERCr, 0, () => ErrorRootCause];
+var ErrorRootCauseServices = [1, n0, _ERCSr, 0, () => ErrorRootCauseService];
+var FaultRootCauseEntityPath = [1, n0, _FRCEP, 0, () => FaultRootCauseEntity];
+var FaultRootCauses = [1, n0, _FRCa, 0, () => FaultRootCause];
+var FaultRootCauseServices = [1, n0, _FRCSa, 0, () => FaultRootCauseService];
+var GroupSummaryList = [1, n0, _GSL, 0, () => GroupSummary];
+var Histogram = [1, n0, _Hi, 0, () => HistogramEntry];
+var IndexingRuleList = [1, n0, _IRL, 0, () => IndexingRule];
+var InsightEventList = [1, n0, _IEL, 0, () => InsightEvent];
+var InsightImpactGraphEdgeList = [1, n0, _IIGEL, 0, () => InsightImpactGraphEdge];
+var InsightImpactGraphServiceList = [1, n0, _IIGSL, 0, () => InsightImpactGraphService];
+var InsightSummaryList = [1, n0, _ISL, 0, () => InsightSummary];
+var LinksList = [1, n0, _LL, 0, () => GraphLink];
+var ResourcePolicyList = [1, n0, _RPL, 0, () => ResourcePolicy];
+var ResponseTimeRootCauseEntityPath = [1, n0, _RTRCEP, 0, () => ResponseTimeRootCauseEntity];
+var ResponseTimeRootCauses = [1, n0, _RTRCe, 0, () => ResponseTimeRootCause];
+var ResponseTimeRootCauseServices = [1, n0, _RTRCSe, 0, () => ResponseTimeRootCauseService];
+var RetrievedServicesList = [1, n0, _RSL, 0, () => RetrievedService];
+var RootCauseExceptions = [1, n0, _RCEo, 0, () => RootCauseException];
+var SamplingBoostStatisticsDocumentList = [
+    1,
+    n0,
+    _SBSDL,
+    0,
+    () => SamplingBoostStatisticsDocument,
+];
+var SamplingRuleRecordList = [1, n0, _SRRL, 0, () => SamplingRuleRecord];
+var SamplingStatisticsDocumentList = [1, n0, _SSDL, 0, () => SamplingStatisticsDocument];
+var SamplingStatisticSummaryList = [1, n0, _SSSL, 0, () => SamplingStatisticSummary];
+var SamplingTargetDocumentList = [1, n0, _STDL, 0, () => SamplingTargetDocument];
+var SegmentList = [1, n0, _SL, 0, () => Segment];
+var ServiceIds = [1, n0, _SIe, 0, () => ServiceId];
+var ServiceList = [1, n0, _SLe, 0, () => Service];
+var SpanList = [1, n0, _SLp, 0, () => Span];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var TelemetryRecordList = [1, n0, _TRL, 0, () => TelemetryRecord];
+var TimeSeriesServiceStatisticsList = [1, n0, _TSSSL, 0, () => TimeSeriesServiceStatistics];
+var TraceAvailabilityZones = [1, n0, _TAZ, 0, () => AvailabilityZoneDetail];
+var TraceInstanceIds = [1, n0, _TII, 0, () => InstanceIdDetail];
+var TraceList = [1, n0, _TLr, 0, () => Trace];
+var TraceResourceARNs = [1, n0, _TRARN, 0, () => ResourceARNDetail];
+var TraceSpanList = [1, n0, _TSL, 0, () => RetrievedTrace];
+var TraceSummaryList = [1, n0, _TSLr, 0, () => TraceSummary];
+var TraceUsers = [1, n0, _TUr, 0, () => TraceUser];
+var UnprocessedStatisticsList = [1, n0, _USL, 0, () => UnprocessedStatistics];
+var UnprocessedTraceSegmentList = [1, n0, _UTSL, 0, () => UnprocessedTraceSegment];
+var ValuesWithServiceIds = [1, n0, _VWSIa, 0, () => ValueWithServiceIds];
+var Annotations = [2, n0, _An, 0, 0, () => ValuesWithServiceIds];
+var AnnotationValue = [3, n0, _AV, 0, [_NV, _BV, _SV], [1, 2, 0]];
+var IndexingRuleValue = [3, n0, _IRV, 0, [_Pro], [() => ProbabilisticRuleValue]];
+var IndexingRuleValueUpdate = [
+    3,
+    n0,
+    _IRVU,
+    0,
+    [_Pro],
+    [() => ProbabilisticRuleValueUpdate],
+];
+var BatchGetTraces = [
+    9,
+    n0,
+    _BGT,
+    {
+        [_h]: ["POST", "/Traces", 200],
+    },
+    () => BatchGetTracesRequest,
+    () => BatchGetTracesResult,
+];
+var CancelTraceRetrieval = [
+    9,
+    n0,
+    _CTR,
+    {
+        [_h]: ["POST", "/CancelTraceRetrieval", 200],
+    },
+    () => CancelTraceRetrievalRequest,
+    () => CancelTraceRetrievalResult,
+];
+var CreateGroup = [
+    9,
+    n0,
+    _CG,
+    {
+        [_h]: ["POST", "/CreateGroup", 200],
+    },
+    () => CreateGroupRequest,
+    () => CreateGroupResult,
+];
+var CreateSamplingRule = [
+    9,
+    n0,
+    _CSR,
+    {
+        [_h]: ["POST", "/CreateSamplingRule", 200],
+    },
+    () => CreateSamplingRuleRequest,
+    () => CreateSamplingRuleResult,
+];
+var DeleteGroup = [
+    9,
+    n0,
+    _DG,
+    {
+        [_h]: ["POST", "/DeleteGroup", 200],
+    },
+    () => DeleteGroupRequest,
+    () => DeleteGroupResult,
+];
+var DeleteResourcePolicy = [
+    9,
+    n0,
+    _DRP,
+    {
+        [_h]: ["POST", "/DeleteResourcePolicy", 200],
+    },
+    () => DeleteResourcePolicyRequest,
+    () => DeleteResourcePolicyResult,
+];
+var DeleteSamplingRule = [
+    9,
+    n0,
+    _DSR,
+    {
+        [_h]: ["POST", "/DeleteSamplingRule", 200],
+    },
+    () => DeleteSamplingRuleRequest,
+    () => DeleteSamplingRuleResult,
+];
+var GetEncryptionConfig = [
+    9,
+    n0,
+    _GEC,
+    {
+        [_h]: ["POST", "/EncryptionConfig", 200],
+    },
+    () => GetEncryptionConfigRequest,
+    () => GetEncryptionConfigResult,
+];
+var GetGroup = [
+    9,
+    n0,
+    _GG,
+    {
+        [_h]: ["POST", "/GetGroup", 200],
+    },
+    () => GetGroupRequest,
+    () => GetGroupResult,
+];
+var GetGroups = [
+    9,
+    n0,
+    _GGe,
+    {
+        [_h]: ["POST", "/Groups", 200],
+    },
+    () => GetGroupsRequest,
+    () => GetGroupsResult,
+];
+var GetIndexingRules = [
+    9,
+    n0,
+    _GIRet,
+    {
+        [_h]: ["POST", "/GetIndexingRules", 200],
+    },
+    () => GetIndexingRulesRequest,
+    () => GetIndexingRulesResult,
+];
+var GetInsight = [
+    9,
+    n0,
+    _GI,
+    {
+        [_h]: ["POST", "/Insight", 200],
+    },
+    () => GetInsightRequest,
+    () => GetInsightResult,
+];
+var GetInsightEvents = [
+    9,
+    n0,
+    _GIE,
+    {
+        [_h]: ["POST", "/InsightEvents", 200],
+    },
+    () => GetInsightEventsRequest,
+    () => GetInsightEventsResult,
+];
+var GetInsightImpactGraph = [
+    9,
+    n0,
+    _GIIG,
+    {
+        [_h]: ["POST", "/InsightImpactGraph", 200],
+    },
+    () => GetInsightImpactGraphRequest,
+    () => GetInsightImpactGraphResult,
+];
+var GetInsightSummaries = [
+    9,
+    n0,
+    _GIS,
+    {
+        [_h]: ["POST", "/InsightSummaries", 200],
+    },
+    () => GetInsightSummariesRequest,
+    () => GetInsightSummariesResult,
+];
+var GetRetrievedTracesGraph = [
+    9,
+    n0,
+    _GRTG,
+    {
+        [_h]: ["POST", "/GetRetrievedTracesGraph", 200],
+    },
+    () => GetRetrievedTracesGraphRequest,
+    () => GetRetrievedTracesGraphResult,
+];
+var GetSamplingRules = [
+    9,
+    n0,
+    _GSR,
+    {
+        [_h]: ["POST", "/GetSamplingRules", 200],
+    },
+    () => GetSamplingRulesRequest,
+    () => GetSamplingRulesResult,
+];
+var GetSamplingStatisticSummaries = [
+    9,
+    n0,
+    _GSSS,
+    {
+        [_h]: ["POST", "/SamplingStatisticSummaries", 200],
+    },
+    () => GetSamplingStatisticSummariesRequest,
+    () => GetSamplingStatisticSummariesResult,
+];
+var GetSamplingTargets = [
+    9,
+    n0,
+    _GST,
+    {
+        [_h]: ["POST", "/SamplingTargets", 200],
+    },
+    () => GetSamplingTargetsRequest,
+    () => GetSamplingTargetsResult,
+];
+var GetServiceGraph = [
+    9,
+    n0,
+    _GSG,
+    {
+        [_h]: ["POST", "/ServiceGraph", 200],
+    },
+    () => GetServiceGraphRequest,
+    () => GetServiceGraphResult,
+];
+var GetTimeSeriesServiceStatistics = [
+    9,
+    n0,
+    _GTSSS,
+    {
+        [_h]: ["POST", "/TimeSeriesServiceStatistics", 200],
+    },
+    () => GetTimeSeriesServiceStatisticsRequest,
+    () => GetTimeSeriesServiceStatisticsResult,
+];
+var GetTraceGraph = [
+    9,
+    n0,
+    _GTG,
+    {
+        [_h]: ["POST", "/TraceGraph", 200],
+    },
+    () => GetTraceGraphRequest,
+    () => GetTraceGraphResult,
+];
+var GetTraceSegmentDestination = [
+    9,
+    n0,
+    _GTSD,
+    {
+        [_h]: ["POST", "/GetTraceSegmentDestination", 200],
+    },
+    () => GetTraceSegmentDestinationRequest,
+    () => GetTraceSegmentDestinationResult,
+];
+var GetTraceSummaries = [
+    9,
+    n0,
+    _GTS,
+    {
+        [_h]: ["POST", "/TraceSummaries", 200],
+    },
+    () => GetTraceSummariesRequest,
+    () => GetTraceSummariesResult,
+];
+var ListResourcePolicies = [
+    9,
+    n0,
+    _LRP,
+    {
+        [_h]: ["POST", "/ListResourcePolicies", 200],
+    },
+    () => ListResourcePoliciesRequest,
+    () => ListResourcePoliciesResult,
+];
+var ListRetrievedTraces = [
+    9,
+    n0,
+    _LRT,
+    {
+        [_h]: ["POST", "/ListRetrievedTraces", 200],
+    },
+    () => ListRetrievedTracesRequest,
+    () => ListRetrievedTracesResult,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["POST", "/ListTagsForResource", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var PutEncryptionConfig = [
+    9,
+    n0,
+    _PEC,
+    {
+        [_h]: ["POST", "/PutEncryptionConfig", 200],
+    },
+    () => PutEncryptionConfigRequest,
+    () => PutEncryptionConfigResult,
+];
+var PutResourcePolicy = [
+    9,
+    n0,
+    _PRP,
+    {
+        [_h]: ["POST", "/PutResourcePolicy", 200],
+    },
+    () => PutResourcePolicyRequest,
+    () => PutResourcePolicyResult,
+];
+var PutTelemetryRecords = [
+    9,
+    n0,
+    _PTR,
+    {
+        [_h]: ["POST", "/TelemetryRecords", 200],
+    },
+    () => PutTelemetryRecordsRequest,
+    () => PutTelemetryRecordsResult,
+];
+var PutTraceSegments = [
+    9,
+    n0,
+    _PTS,
+    {
+        [_h]: ["POST", "/TraceSegments", 200],
+    },
+    () => PutTraceSegmentsRequest,
+    () => PutTraceSegmentsResult,
+];
+var StartTraceRetrieval = [
+    9,
+    n0,
+    _STR,
+    {
+        [_h]: ["POST", "/StartTraceRetrieval", 200],
+    },
+    () => StartTraceRetrievalRequest,
+    () => StartTraceRetrievalResult,
+];
+var TagResource = [
+    9,
+    n0,
+    _TRa,
+    {
+        [_h]: ["POST", "/TagResource", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["POST", "/UntagResource", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateGroup = [
+    9,
+    n0,
+    _UG,
+    {
+        [_h]: ["POST", "/UpdateGroup", 200],
+    },
+    () => UpdateGroupRequest,
+    () => UpdateGroupResult,
+];
+var UpdateIndexingRule = [
+    9,
+    n0,
+    _UIR,
+    {
+        [_h]: ["POST", "/UpdateIndexingRule", 200],
+    },
+    () => UpdateIndexingRuleRequest,
+    () => UpdateIndexingRuleResult,
+];
+var UpdateSamplingRule = [
+    9,
+    n0,
+    _USR,
+    {
+        [_h]: ["POST", "/UpdateSamplingRule", 200],
+    },
+    () => UpdateSamplingRuleRequest,
+    () => UpdateSamplingRuleResult,
+];
+var UpdateTraceSegmentDestination = [
+    9,
+    n0,
+    _UTSD,
+    {
+        [_h]: ["POST", "/UpdateTraceSegmentDestination", 200],
+    },
+    () => UpdateTraceSegmentDestinationRequest,
+    () => UpdateTraceSegmentDestinationResult,
+];
 
 class BatchGetTracesCommand 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("AWSXRay", "BatchGetTraces", {})
     .n("XRayClient", "BatchGetTracesCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchGetTracesCommand)
-    .de(de_BatchGetTracesCommand)
+    .sc(BatchGetTraces)
     .build() {
 }
 
@@ -2173,16 +1891,11 @@ class CancelTraceRetrievalCommand 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("AWSXRay", "CancelTraceRetrieval", {})
     .n("XRayClient", "CancelTraceRetrievalCommand")
-    .f(void 0, void 0)
-    .ser(se_CancelTraceRetrievalCommand)
-    .de(de_CancelTraceRetrievalCommand)
+    .sc(CancelTraceRetrieval)
     .build() {
 }
 
@@ -2190,16 +1903,11 @@ class CreateGroupCommand 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("AWSXRay", "CreateGroup", {})
     .n("XRayClient", "CreateGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateGroupCommand)
-    .de(de_CreateGroupCommand)
+    .sc(CreateGroup)
     .build() {
 }
 
@@ -2207,16 +1915,11 @@ class CreateSamplingRuleCommand 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("AWSXRay", "CreateSamplingRule", {})
     .n("XRayClient", "CreateSamplingRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateSamplingRuleCommand)
-    .de(de_CreateSamplingRuleCommand)
+    .sc(CreateSamplingRule)
     .build() {
 }
 
@@ -2224,16 +1927,11 @@ class DeleteGroupCommand 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("AWSXRay", "DeleteGroup", {})
     .n("XRayClient", "DeleteGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteGroupCommand)
-    .de(de_DeleteGroupCommand)
+    .sc(DeleteGroup)
     .build() {
 }
 
@@ -2241,16 +1939,11 @@ class DeleteResourcePolicyCommand 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("AWSXRay", "DeleteResourcePolicy", {})
     .n("XRayClient", "DeleteResourcePolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteResourcePolicyCommand)
-    .de(de_DeleteResourcePolicyCommand)
+    .sc(DeleteResourcePolicy)
     .build() {
 }
 
@@ -2258,16 +1951,11 @@ class DeleteSamplingRuleCommand 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("AWSXRay", "DeleteSamplingRule", {})
     .n("XRayClient", "DeleteSamplingRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteSamplingRuleCommand)
-    .de(de_DeleteSamplingRuleCommand)
+    .sc(DeleteSamplingRule)
     .build() {
 }
 
@@ -2275,16 +1963,11 @@ class GetEncryptionConfigCommand 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("AWSXRay", "GetEncryptionConfig", {})
     .n("XRayClient", "GetEncryptionConfigCommand")
-    .f(void 0, void 0)
-    .ser(se_GetEncryptionConfigCommand)
-    .de(de_GetEncryptionConfigCommand)
+    .sc(GetEncryptionConfig)
     .build() {
 }
 
@@ -2292,16 +1975,11 @@ class GetGroupCommand 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("AWSXRay", "GetGroup", {})
     .n("XRayClient", "GetGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_GetGroupCommand)
-    .de(de_GetGroupCommand)
+    .sc(GetGroup)
     .build() {
 }
 
@@ -2309,16 +1987,11 @@ class GetGroupsCommand 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("AWSXRay", "GetGroups", {})
     .n("XRayClient", "GetGroupsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetGroupsCommand)
-    .de(de_GetGroupsCommand)
+    .sc(GetGroups)
     .build() {
 }
 
@@ -2326,16 +1999,11 @@ class GetIndexingRulesCommand 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("AWSXRay", "GetIndexingRules", {})
     .n("XRayClient", "GetIndexingRulesCommand")
-    .f(void 0, void 0)
-    .ser(se_GetIndexingRulesCommand)
-    .de(de_GetIndexingRulesCommand)
+    .sc(GetIndexingRules)
     .build() {
 }
 
@@ -2343,16 +2011,11 @@ class GetInsightCommand 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("AWSXRay", "GetInsight", {})
     .n("XRayClient", "GetInsightCommand")
-    .f(void 0, void 0)
-    .ser(se_GetInsightCommand)
-    .de(de_GetInsightCommand)
+    .sc(GetInsight)
     .build() {
 }
 
@@ -2360,16 +2023,11 @@ class GetInsightEventsCommand 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("AWSXRay", "GetInsightEvents", {})
     .n("XRayClient", "GetInsightEventsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetInsightEventsCommand)
-    .de(de_GetInsightEventsCommand)
+    .sc(GetInsightEvents)
     .build() {
 }
 
@@ -2377,16 +2035,11 @@ class GetInsightImpactGraphCommand 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("AWSXRay", "GetInsightImpactGraph", {})
     .n("XRayClient", "GetInsightImpactGraphCommand")
-    .f(void 0, void 0)
-    .ser(se_GetInsightImpactGraphCommand)
-    .de(de_GetInsightImpactGraphCommand)
+    .sc(GetInsightImpactGraph)
     .build() {
 }
 
@@ -2394,16 +2047,11 @@ class GetInsightSummariesCommand 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("AWSXRay", "GetInsightSummaries", {})
     .n("XRayClient", "GetInsightSummariesCommand")
-    .f(void 0, void 0)
-    .ser(se_GetInsightSummariesCommand)
-    .de(de_GetInsightSummariesCommand)
+    .sc(GetInsightSummaries)
     .build() {
 }
 
@@ -2411,16 +2059,11 @@ class GetRetrievedTracesGraphCommand 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("AWSXRay", "GetRetrievedTracesGraph", {})
     .n("XRayClient", "GetRetrievedTracesGraphCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRetrievedTracesGraphCommand)
-    .de(de_GetRetrievedTracesGraphCommand)
+    .sc(GetRetrievedTracesGraph)
     .build() {
 }
 
@@ -2428,16 +2071,11 @@ class GetSamplingRulesCommand 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("AWSXRay", "GetSamplingRules", {})
     .n("XRayClient", "GetSamplingRulesCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSamplingRulesCommand)
-    .de(de_GetSamplingRulesCommand)
+    .sc(GetSamplingRules)
     .build() {
 }
 
@@ -2445,16 +2083,11 @@ class GetSamplingStatisticSummariesCommand 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("AWSXRay", "GetSamplingStatisticSummaries", {})
     .n("XRayClient", "GetSamplingStatisticSummariesCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSamplingStatisticSummariesCommand)
-    .de(de_GetSamplingStatisticSummariesCommand)
+    .sc(GetSamplingStatisticSummaries)
     .build() {
 }
 
@@ -2462,16 +2095,11 @@ class GetSamplingTargetsCommand 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("AWSXRay", "GetSamplingTargets", {})
     .n("XRayClient", "GetSamplingTargetsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSamplingTargetsCommand)
-    .de(de_GetSamplingTargetsCommand)
+    .sc(GetSamplingTargets)
     .build() {
 }
 
@@ -2479,16 +2107,11 @@ class GetServiceGraphCommand 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("AWSXRay", "GetServiceGraph", {})
     .n("XRayClient", "GetServiceGraphCommand")
-    .f(void 0, void 0)
-    .ser(se_GetServiceGraphCommand)
-    .de(de_GetServiceGraphCommand)
+    .sc(GetServiceGraph)
     .build() {
 }
 
@@ -2496,16 +2119,11 @@ class GetTimeSeriesServiceStatisticsCommand 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("AWSXRay", "GetTimeSeriesServiceStatistics", {})
     .n("XRayClient", "GetTimeSeriesServiceStatisticsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTimeSeriesServiceStatisticsCommand)
-    .de(de_GetTimeSeriesServiceStatisticsCommand)
+    .sc(GetTimeSeriesServiceStatistics)
     .build() {
 }
 
@@ -2513,16 +2131,11 @@ class GetTraceGraphCommand 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("AWSXRay", "GetTraceGraph", {})
     .n("XRayClient", "GetTraceGraphCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTraceGraphCommand)
-    .de(de_GetTraceGraphCommand)
+    .sc(GetTraceGraph)
     .build() {
 }
 
@@ -2530,16 +2143,11 @@ class GetTraceSegmentDestinationCommand 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("AWSXRay", "GetTraceSegmentDestination", {})
     .n("XRayClient", "GetTraceSegmentDestinationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTraceSegmentDestinationCommand)
-    .de(de_GetTraceSegmentDestinationCommand)
+    .sc(GetTraceSegmentDestination)
     .build() {
 }
 
@@ -2547,16 +2155,11 @@ class GetTraceSummariesCommand 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("AWSXRay", "GetTraceSummaries", {})
     .n("XRayClient", "GetTraceSummariesCommand")
-    .f(void 0, void 0)
-    .ser(se_GetTraceSummariesCommand)
-    .de(de_GetTraceSummariesCommand)
+    .sc(GetTraceSummaries)
     .build() {
 }
 
@@ -2564,16 +2167,11 @@ class ListResourcePoliciesCommand 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("AWSXRay", "ListResourcePolicies", {})
     .n("XRayClient", "ListResourcePoliciesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListResourcePoliciesCommand)
-    .de(de_ListResourcePoliciesCommand)
+    .sc(ListResourcePolicies)
     .build() {
 }
 
@@ -2581,16 +2179,11 @@ class ListRetrievedTracesCommand 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("AWSXRay", "ListRetrievedTraces", {})
     .n("XRayClient", "ListRetrievedTracesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListRetrievedTracesCommand)
-    .de(de_ListRetrievedTracesCommand)
+    .sc(ListRetrievedTraces)
     .build() {
 }
 
@@ -2598,16 +2191,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("AWSXRay", "ListTagsForResource", {})
     .n("XRayClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2615,16 +2203,11 @@ class PutEncryptionConfigCommand 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("AWSXRay", "PutEncryptionConfig", {})
     .n("XRayClient", "PutEncryptionConfigCommand")
-    .f(void 0, void 0)
-    .ser(se_PutEncryptionConfigCommand)
-    .de(de_PutEncryptionConfigCommand)
+    .sc(PutEncryptionConfig)
     .build() {
 }
 
@@ -2632,16 +2215,11 @@ class PutResourcePolicyCommand 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("AWSXRay", "PutResourcePolicy", {})
     .n("XRayClient", "PutResourcePolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_PutResourcePolicyCommand)
-    .de(de_PutResourcePolicyCommand)
+    .sc(PutResourcePolicy)
     .build() {
 }
 
@@ -2649,16 +2227,11 @@ class PutTelemetryRecordsCommand 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("AWSXRay", "PutTelemetryRecords", {})
     .n("XRayClient", "PutTelemetryRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_PutTelemetryRecordsCommand)
-    .de(de_PutTelemetryRecordsCommand)
+    .sc(PutTelemetryRecords)
     .build() {
 }
 
@@ -2666,16 +2239,11 @@ class PutTraceSegmentsCommand 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("AWSXRay", "PutTraceSegments", {})
     .n("XRayClient", "PutTraceSegmentsCommand")
-    .f(void 0, void 0)
-    .ser(se_PutTraceSegmentsCommand)
-    .de(de_PutTraceSegmentsCommand)
+    .sc(PutTraceSegments)
     .build() {
 }
 
@@ -2683,16 +2251,11 @@ class StartTraceRetrievalCommand 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("AWSXRay", "StartTraceRetrieval", {})
     .n("XRayClient", "StartTraceRetrievalCommand")
-    .f(void 0, void 0)
-    .ser(se_StartTraceRetrievalCommand)
-    .de(de_StartTraceRetrievalCommand)
+    .sc(StartTraceRetrieval)
     .build() {
 }
 
@@ -2700,16 +2263,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("AWSXRay", "TagResource", {})
     .n("XRayClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2717,16 +2275,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("AWSXRay", "UntagResource", {})
     .n("XRayClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2734,16 +2287,11 @@ class UpdateGroupCommand 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("AWSXRay", "UpdateGroup", {})
     .n("XRayClient", "UpdateGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateGroupCommand)
-    .de(de_UpdateGroupCommand)
+    .sc(UpdateGroup)
     .build() {
 }
 
@@ -2751,16 +2299,11 @@ class UpdateIndexingRuleCommand 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("AWSXRay", "UpdateIndexingRule", {})
     .n("XRayClient", "UpdateIndexingRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateIndexingRuleCommand)
-    .de(de_UpdateIndexingRuleCommand)
+    .sc(UpdateIndexingRule)
     .build() {
 }
 
@@ -2768,16 +2311,11 @@ class UpdateSamplingRuleCommand 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("AWSXRay", "UpdateSamplingRule", {})
     .n("XRayClient", "UpdateSamplingRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateSamplingRuleCommand)
-    .de(de_UpdateSamplingRuleCommand)
+    .sc(UpdateSamplingRule)
     .build() {
 }
 
@@ -2785,16 +2323,11 @@ class UpdateTraceSegmentDestinationCommand 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("AWSXRay", "UpdateTraceSegmentDestination", {})
     .n("XRayClient", "UpdateTraceSegmentDestinationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateTraceSegmentDestinationCommand)
-    .de(de_UpdateTraceSegmentDestinationCommand)
+    .sc(UpdateTraceSegmentDestination)
     .build() {
 }
 
@@ -2902,28 +2435,28 @@ exports.GetTraceSegmentDestinationCommand = GetTraceSegmentDestinationCommand;
 exports.GetTraceSummariesCommand = GetTraceSummariesCommand;
 exports.InsightCategory = InsightCategory;
 exports.InsightState = InsightState;
-exports.InvalidPolicyRevisionIdException = InvalidPolicyRevisionIdException;
-exports.InvalidRequestException = InvalidRequestException;
+exports.InvalidPolicyRevisionIdException = InvalidPolicyRevisionIdException$1;
+exports.InvalidRequestException = InvalidRequestException$1;
 exports.ListResourcePoliciesCommand = ListResourcePoliciesCommand;
 exports.ListRetrievedTracesCommand = ListRetrievedTracesCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
-exports.LockoutPreventionException = LockoutPreventionException;
-exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException;
-exports.PolicyCountLimitExceededException = PolicyCountLimitExceededException;
-exports.PolicySizeLimitExceededException = PolicySizeLimitExceededException;
+exports.LockoutPreventionException = LockoutPreventionException$1;
+exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException$1;
+exports.PolicyCountLimitExceededException = PolicyCountLimitExceededException$1;
+exports.PolicySizeLimitExceededException = PolicySizeLimitExceededException$1;
 exports.PutEncryptionConfigCommand = PutEncryptionConfigCommand;
 exports.PutResourcePolicyCommand = PutResourcePolicyCommand;
 exports.PutTelemetryRecordsCommand = PutTelemetryRecordsCommand;
 exports.PutTraceSegmentsCommand = PutTraceSegmentsCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.RetrievalStatus = RetrievalStatus;
-exports.RuleLimitExceededException = RuleLimitExceededException;
+exports.RuleLimitExceededException = RuleLimitExceededException$1;
 exports.SamplingStrategyName = SamplingStrategyName;
 exports.StartTraceRetrievalCommand = StartTraceRetrievalCommand;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottledException = ThrottledException;
+exports.ThrottledException = ThrottledException$1;
 exports.TimeRangeType = TimeRangeType;
-exports.TooManyTagsException = TooManyTagsException;
+exports.TooManyTagsException = TooManyTagsException$1;
 exports.TraceFormatType = TraceFormatType;
 exports.TraceSegmentDestination = TraceSegmentDestination;
 exports.TraceSegmentDestinationStatus = TraceSegmentDestinationStatus;
@@ -2934,7 +2467,7 @@ exports.UpdateSamplingRuleCommand = UpdateSamplingRuleCommand;
 exports.UpdateTraceSegmentDestinationCommand = UpdateTraceSegmentDestinationCommand;
 exports.XRay = XRay;
 exports.XRayClient = XRayClient;
-exports.XRayServiceException = XRayServiceException;
+exports.XRayServiceException = XRayServiceException$1;
 exports.paginateBatchGetTraces = paginateBatchGetTraces;
 exports.paginateGetGroups = paginateGetGroups;
 exports.paginateGetInsightEvents = paginateGetInsightEvents;