@aws-sdk/client-xray 3.1074.0 → 3.1076.0

package/dist-cjs/index.js

@@ -1,21 +1,57 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultXRayHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { BatchGetTraces$, CancelTraceRetrieval$, CreateGroup$, CreateSamplingRule$, DeleteGroup$, DeleteResourcePolicy$, DeleteSamplingRule$, GetEncryptionConfig$, GetGroup$, GetGroups$, GetIndexingRules$, GetInsight$, GetInsightEvents$, GetInsightImpactGraph$, GetInsightSummaries$, GetRetrievedTracesGraph$, GetSamplingRules$, GetSamplingStatisticSummaries$, GetSamplingTargets$, GetServiceGraph$, GetTimeSeriesServiceStatistics$, GetTraceGraph$, GetTraceSegmentDestination$, GetTraceSummaries$, ListResourcePolicies$, ListRetrievedTraces$, ListTagsForResource$, PutEncryptionConfig$, PutResourcePolicy$, PutTelemetryRecords$, PutTraceSegments$, StartTraceRetrieval$, TagResource$, UntagResource$, UpdateGroup$, UpdateIndexingRule$, UpdateSamplingRule$, UpdateTraceSegmentDestination$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { XRayServiceException } = require("./models/XRayServiceException");
-exports.XRayServiceException = XRayServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, toBase64, fromBase64, Hash, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsRestJsonProtocol } = require("@aws-sdk/core/protocols");
+
+const defaultXRayHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "xray",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultXRayHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -31,6 +67,1739 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1075.0";
+var packageInfo = {
+	version: version};
+
+const k = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = { [k]: "Endpoint" }, h = { [k]: d }, i = {}, j = [{ [k]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [g]],
+        [c, j],
+        ["aws.partition", j, d],
+        [e, [{ [k]: "UseFIPS" }, b]],
+        [e, [{ [k]: "UseDualStack" }, b]],
+        [e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
+        [e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [g, i],
+        ["https://xray-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://xray-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://xray.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://xray.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 12, 3,
+    1, 4, r + 11,
+    2, 5, r + 11,
+    3, 8, 6,
+    4, 7, r + 10,
+    5, r + 8, r + 9,
+    4, 10, 9,
+    6, r + 6, r + 7,
+    5, 11, r + 5,
+    6, r + 4, r + 5,
+    3, r + 1, 13,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class XRayServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, XRayServiceException.prototype);
+    }
+}
+
+class InvalidRequestException extends XRayServiceException {
+    name = "InvalidRequestException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InvalidRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRequestException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ThrottledException extends XRayServiceException {
+    name = "ThrottledException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ThrottledException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottledException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ResourceNotFoundException extends XRayServiceException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    Message;
+    ResourceName;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+        this.ResourceName = opts.ResourceName;
+    }
+}
+class RuleLimitExceededException extends XRayServiceException {
+    name = "RuleLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "RuleLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RuleLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class InvalidPolicyRevisionIdException extends XRayServiceException {
+    name = "InvalidPolicyRevisionIdException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InvalidPolicyRevisionIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidPolicyRevisionIdException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class LockoutPreventionException extends XRayServiceException {
+    name = "LockoutPreventionException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "LockoutPreventionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LockoutPreventionException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class MalformedPolicyDocumentException extends XRayServiceException {
+    name = "MalformedPolicyDocumentException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "MalformedPolicyDocumentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class PolicyCountLimitExceededException extends XRayServiceException {
+    name = "PolicyCountLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "PolicyCountLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PolicyCountLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class PolicySizeLimitExceededException extends XRayServiceException {
+    name = "PolicySizeLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "PolicySizeLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PolicySizeLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class TooManyTagsException extends XRayServiceException {
+    name = "TooManyTagsException";
+    $fault = "client";
+    Message;
+    ResourceName;
+    constructor(opts) {
+        super({
+            name: "TooManyTagsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TooManyTagsException.prototype);
+        this.Message = opts.Message;
+        this.ResourceName = opts.ResourceName;
+    }
+}
+
+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 = "ResourceName";
+const _RNFE = "ResourceNotFoundException";
+const _RNu = "RuleName";
+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";
+const _s_registry = TypeRegistry.for(_s);
+var XRayServiceException$ = [-3, _s, "XRayServiceException", 0, [], []];
+_s_registry.registerError(XRayServiceException$, XRayServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var InvalidPolicyRevisionIdException$ = [-3, n0, _IPRIE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(InvalidPolicyRevisionIdException$, InvalidPolicyRevisionIdException);
+var InvalidRequestException$ = [-3, n0, _IRE,
+    { [_e]: _c },
+    [_M],
+    [0]
+];
+n0_registry.registerError(InvalidRequestException$, InvalidRequestException);
+var LockoutPreventionException$ = [-3, n0, _LPE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(LockoutPreventionException$, LockoutPreventionException);
+var MalformedPolicyDocumentException$ = [-3, n0, _MPDE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(MalformedPolicyDocumentException$, MalformedPolicyDocumentException);
+var PolicyCountLimitExceededException$ = [-3, n0, _PCLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(PolicyCountLimitExceededException$, PolicyCountLimitExceededException);
+var PolicySizeLimitExceededException$ = [-3, n0, _PSLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(PolicySizeLimitExceededException$, PolicySizeLimitExceededException);
+var ResourceNotFoundException$ = [-3, n0, _RNFE,
+    { [_e]: _c, [_hE]: 404 },
+    [_M, _RN],
+    [0, 0]
+];
+n0_registry.registerError(ResourceNotFoundException$, ResourceNotFoundException);
+var RuleLimitExceededException$ = [-3, n0, _RLEE,
+    { [_e]: _c },
+    [_M],
+    [0]
+];
+n0_registry.registerError(RuleLimitExceededException$, RuleLimitExceededException);
+var ThrottledException$ = [-3, n0, _TE,
+    { [_e]: _c, [_hE]: 429 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(ThrottledException$, ThrottledException);
+var TooManyTagsException$ = [-3, n0, _TMTE,
+    { [_e]: _c, [_hE]: 400 },
+    [_M, _RN],
+    [0, 0]
+];
+n0_registry.registerError(TooManyTagsException$, TooManyTagsException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+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], 1
+];
+var BatchGetTracesResult$ = [3, n0, _BGTRa,
+    0,
+    [_Tr, _UTI, _NT],
+    [() => TraceList, 64 | 0, 0]
+];
+var CancelTraceRetrievalRequest$ = [3, n0, _CTRR,
+    0,
+    [_RT],
+    [0], 1
+];
+var CancelTraceRetrievalResult$ = [3, n0, _CTRRa,
+    0,
+    [],
+    []
+];
+var CreateGroupRequest$ = [3, n0, _CGR,
+    0,
+    [_GN, _FE, _IC, _Ta],
+    [0, 0, () => InsightsConfiguration$, () => TagList], 1
+];
+var CreateGroupResult$ = [3, n0, _CGRr,
+    0,
+    [_G],
+    [() => Group$]
+];
+var CreateSamplingRuleRequest$ = [3, n0, _CSRR,
+    0,
+    [_SR, _Ta],
+    [() => SamplingRule$, () => TagList], 1
+];
+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], 1
+];
+var DeleteResourcePolicyResult$ = [3, n0, _DRPRe,
+    0,
+    [],
+    []
+];
+var DeleteSamplingRuleRequest$ = [3, n0, _DSRR,
+    0,
+    [_RNu, _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], 1
+];
+var GetInsightEventsResult$ = [3, n0, _GIERe,
+    0,
+    [_IE, _NT],
+    [() => InsightEventList, 0]
+];
+var GetInsightImpactGraphRequest$ = [3, n0, _GIIGR,
+    0,
+    [_II, _ST, _ET, _NT],
+    [0, 4, 4, 0], 3
+];
+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], 1
+];
+var GetInsightResult$ = [3, n0, _GIRe,
+    0,
+    [_In],
+    [() => Insight$]
+];
+var GetInsightSummariesRequest$ = [3, n0, _GISR,
+    0,
+    [_ST, _ET, _St, _GARN, _GN, _MR, _NT],
+    [4, 4, 64 | 0, 0, 0, 1, 0], 2
+];
+var GetInsightSummariesResult$ = [3, n0, _GISRe,
+    0,
+    [_IS, _NT],
+    [() => InsightSummaryList, 0]
+];
+var GetRetrievedTracesGraphRequest$ = [3, n0, _GRTGR,
+    0,
+    [_RT, _NT],
+    [0, 0], 1
+];
+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], 1
+];
+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], 2
+];
+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], 2
+];
+var GetTimeSeriesServiceStatisticsResult$ = [3, n0, _GTSSSRe,
+    0,
+    [_TSSS, _COGV, _NT],
+    [() => TimeSeriesServiceStatisticsList, 2, 0]
+];
+var GetTraceGraphRequest$ = [3, n0, _GTGR,
+    0,
+    [_TI, _NT],
+    [64 | 0, 0], 1
+];
+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], 2
+];
+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 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], 1
+];
+var ListRetrievedTracesResult$ = [3, n0, _LRTRi,
+    0,
+    [_RS, _TF, _Tr, _NT],
+    [0, 0, () => TraceSpanList, 0]
+];
+var ListTagsForResourceRequest$ = [3, n0, _LTFRR,
+    0,
+    [_RARNe, _NT],
+    [0, 0], 1
+];
+var ListTagsForResourceResponse$ = [3, n0, _LTFRRi,
+    0,
+    [_Ta, _NT],
+    [() => TagList, 0]
+];
+var ProbabilisticRuleValue$ = [3, n0, _PRV,
+    0,
+    [_DSP, _ASP],
+    [1, 1], 1
+];
+var ProbabilisticRuleValueUpdate$ = [3, n0, _PRVU,
+    0,
+    [_DSP],
+    [1], 1
+];
+var PutEncryptionConfigRequest$ = [3, n0, _PECR,
+    0,
+    [_T, _KI],
+    [0, 0], 1
+];
+var PutEncryptionConfigResult$ = [3, n0, _PECRu,
+    0,
+    [_EC],
+    [() => EncryptionConfig$]
+];
+var PutResourcePolicyRequest$ = [3, n0, _PRPR,
+    0,
+    [_PN, _PD, _PRI, _BPLC],
+    [0, 0, 0, 2], 2
+];
+var PutResourcePolicyResult$ = [3, n0, _PRPRu,
+    0,
+    [_RPe],
+    [() => ResourcePolicy$]
+];
+var PutTelemetryRecordsRequest$ = [3, n0, _PTRR,
+    0,
+    [_TR, _ECII, _Ho, _RARNe],
+    [() => TelemetryRecordList, 0, 0, 0], 1
+];
+var PutTelemetryRecordsResult$ = [3, n0, _PTRRu,
+    0,
+    [],
+    []
+];
+var PutTraceSegmentsRequest$ = [3, n0, _PTSR,
+    0,
+    [_TSD],
+    [64 | 0], 1
+];
+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 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 SamplingBoost$ = [3, n0, _SB,
+    0,
+    [_BR, _BRTTL],
+    [1, 4], 2
+];
+var SamplingBoostStatisticsDocument$ = [3, n0, _SBSDa,
+    0,
+    [_RNu, _SN, _Ti, _AC, _TCo, _SAC],
+    [0, 0, 4, 1, 1, 1], 6
+];
+var SamplingRateBoost$ = [3, n0, _SRB,
+    0,
+    [_MRa, _CWM],
+    [1, 1], 2
+];
+var SamplingRule$ = [3, n0, _SR,
+    0,
+    [_RARNe, _Pr, _FR, _RSes, _SN, _STe, _Hos, _HTTPM, _URLP, _Ve, _RNu, _RARN, _At, _SRB],
+    [0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 128 | 0, () => SamplingRateBoost$], 10
+];
+var SamplingRuleRecord$ = [3, n0, _SRR,
+    0,
+    [_SR, _CA, _MA],
+    [() => SamplingRule$, 4, 4]
+];
+var SamplingRuleUpdate$ = [3, n0, _SRU,
+    0,
+    [_RNu, _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,
+    [_RNu, _CID, _Ti, _RC, _SC, _BC],
+    [0, 0, 4, 1, 1, 1], 5
+];
+var SamplingStatisticSummary$ = [3, n0, _SSSa,
+    0,
+    [_RNu, _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,
+    [_RNu, _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], 3
+];
+var StartTraceRetrievalResult$ = [3, n0, _STRRt,
+    0,
+    [_RT],
+    [0]
+];
+var Tag$ = [3, n0, _Tag,
+    0,
+    [_K, _V],
+    [0, 0], 2
+];
+var TagResourceRequest$ = [3, n0, _TRR,
+    0,
+    [_RARNe, _Ta],
+    [0, () => TagList], 2
+];
+var TagResourceResponse$ = [3, n0, _TRRa,
+    0,
+    [],
+    []
+];
+var TelemetryRecord$ = [3, n0, _TRe,
+    0,
+    [_Ti, _SRC, _SSC, _SSCe, _SRCe, _BCE],
+    [4, 1, 1, 1, 1, () => BackendConnectionErrors$], 1
+];
+var TimeSeriesServiceStatistics$ = [3, n0, _TSSS,
+    0,
+    [_Ti, _ESS, _SSSe, _SFS, _RTH],
+    [4, () => EdgeStatistics$, () => ServiceStatistics$, () => ForecastStatistics$, () => Histogram]
+];
+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,
+    [_RNu, _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], 2
+];
+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$], 2
+];
+var UpdateIndexingRuleResult$ = [3, n0, _UIRRp,
+    0,
+    [_IRn],
+    [() => IndexingRule$]
+];
+var UpdateSamplingRuleRequest$ = [3, n0, _USRR,
+    0,
+    [_SRU],
+    [() => SamplingRuleUpdate$], 1
+];
+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 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$ = [4, n0, _AV,
+    0,
+    [_NV, _BV, _SV],
+    [1, 2, 0]
+];
+var IndexingRuleValue$ = [4, n0, _IRV,
+    0,
+    [_Pro],
+    [() => ProbabilisticRuleValue$]
+];
+var IndexingRuleValueUpdate$ = [4, 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$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2016-04-12",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultXRayHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsRestJsonProtocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.xray",
+            errorTypeRegistries,
+            version: "2016-04-12",
+            serviceTarget: "AWSXRay",
+        },
+        serviceId: config?.serviceId ?? "XRay",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -694,56 +2463,260 @@ const TraceFormatType = {
     XRAY: "XRAY",
 };
 
+exports.Alias$ = Alias$;
+exports.AnnotationValue$ = AnnotationValue$;
+exports.AnomalousService$ = AnomalousService$;
+exports.AvailabilityZoneDetail$ = AvailabilityZoneDetail$;
+exports.BackendConnectionErrors$ = BackendConnectionErrors$;
+exports.BatchGetTraces$ = BatchGetTraces$;
 exports.BatchGetTracesCommand = BatchGetTracesCommand;
+exports.BatchGetTracesRequest$ = BatchGetTracesRequest$;
+exports.BatchGetTracesResult$ = BatchGetTracesResult$;
+exports.CancelTraceRetrieval$ = CancelTraceRetrieval$;
 exports.CancelTraceRetrievalCommand = CancelTraceRetrievalCommand;
+exports.CancelTraceRetrievalRequest$ = CancelTraceRetrievalRequest$;
+exports.CancelTraceRetrievalResult$ = CancelTraceRetrievalResult$;
+exports.CreateGroup$ = CreateGroup$;
 exports.CreateGroupCommand = CreateGroupCommand;
+exports.CreateGroupRequest$ = CreateGroupRequest$;
+exports.CreateGroupResult$ = CreateGroupResult$;
+exports.CreateSamplingRule$ = CreateSamplingRule$;
 exports.CreateSamplingRuleCommand = CreateSamplingRuleCommand;
+exports.CreateSamplingRuleRequest$ = CreateSamplingRuleRequest$;
+exports.CreateSamplingRuleResult$ = CreateSamplingRuleResult$;
+exports.DeleteGroup$ = DeleteGroup$;
 exports.DeleteGroupCommand = DeleteGroupCommand;
+exports.DeleteGroupRequest$ = DeleteGroupRequest$;
+exports.DeleteGroupResult$ = DeleteGroupResult$;
+exports.DeleteResourcePolicy$ = DeleteResourcePolicy$;
 exports.DeleteResourcePolicyCommand = DeleteResourcePolicyCommand;
+exports.DeleteResourcePolicyRequest$ = DeleteResourcePolicyRequest$;
+exports.DeleteResourcePolicyResult$ = DeleteResourcePolicyResult$;
+exports.DeleteSamplingRule$ = DeleteSamplingRule$;
 exports.DeleteSamplingRuleCommand = DeleteSamplingRuleCommand;
+exports.DeleteSamplingRuleRequest$ = DeleteSamplingRuleRequest$;
+exports.DeleteSamplingRuleResult$ = DeleteSamplingRuleResult$;
+exports.Edge$ = Edge$;
+exports.EdgeStatistics$ = EdgeStatistics$;
+exports.EncryptionConfig$ = EncryptionConfig$;
 exports.EncryptionStatus = EncryptionStatus;
 exports.EncryptionType = EncryptionType;
+exports.ErrorRootCause$ = ErrorRootCause$;
+exports.ErrorRootCauseEntity$ = ErrorRootCauseEntity$;
+exports.ErrorRootCauseService$ = ErrorRootCauseService$;
+exports.ErrorStatistics$ = ErrorStatistics$;
+exports.FaultRootCause$ = FaultRootCause$;
+exports.FaultRootCauseEntity$ = FaultRootCauseEntity$;
+exports.FaultRootCauseService$ = FaultRootCauseService$;
+exports.FaultStatistics$ = FaultStatistics$;
+exports.ForecastStatistics$ = ForecastStatistics$;
+exports.GetEncryptionConfig$ = GetEncryptionConfig$;
 exports.GetEncryptionConfigCommand = GetEncryptionConfigCommand;
+exports.GetEncryptionConfigRequest$ = GetEncryptionConfigRequest$;
+exports.GetEncryptionConfigResult$ = GetEncryptionConfigResult$;
+exports.GetGroup$ = GetGroup$;
 exports.GetGroupCommand = GetGroupCommand;
+exports.GetGroupRequest$ = GetGroupRequest$;
+exports.GetGroupResult$ = GetGroupResult$;
+exports.GetGroups$ = GetGroups$;
 exports.GetGroupsCommand = GetGroupsCommand;
+exports.GetGroupsRequest$ = GetGroupsRequest$;
+exports.GetGroupsResult$ = GetGroupsResult$;
+exports.GetIndexingRules$ = GetIndexingRules$;
 exports.GetIndexingRulesCommand = GetIndexingRulesCommand;
+exports.GetIndexingRulesRequest$ = GetIndexingRulesRequest$;
+exports.GetIndexingRulesResult$ = GetIndexingRulesResult$;
+exports.GetInsight$ = GetInsight$;
 exports.GetInsightCommand = GetInsightCommand;
+exports.GetInsightEvents$ = GetInsightEvents$;
 exports.GetInsightEventsCommand = GetInsightEventsCommand;
+exports.GetInsightEventsRequest$ = GetInsightEventsRequest$;
+exports.GetInsightEventsResult$ = GetInsightEventsResult$;
+exports.GetInsightImpactGraph$ = GetInsightImpactGraph$;
 exports.GetInsightImpactGraphCommand = GetInsightImpactGraphCommand;
+exports.GetInsightImpactGraphRequest$ = GetInsightImpactGraphRequest$;
+exports.GetInsightImpactGraphResult$ = GetInsightImpactGraphResult$;
+exports.GetInsightRequest$ = GetInsightRequest$;
+exports.GetInsightResult$ = GetInsightResult$;
+exports.GetInsightSummaries$ = GetInsightSummaries$;
 exports.GetInsightSummariesCommand = GetInsightSummariesCommand;
+exports.GetInsightSummariesRequest$ = GetInsightSummariesRequest$;
+exports.GetInsightSummariesResult$ = GetInsightSummariesResult$;
+exports.GetRetrievedTracesGraph$ = GetRetrievedTracesGraph$;
 exports.GetRetrievedTracesGraphCommand = GetRetrievedTracesGraphCommand;
+exports.GetRetrievedTracesGraphRequest$ = GetRetrievedTracesGraphRequest$;
+exports.GetRetrievedTracesGraphResult$ = GetRetrievedTracesGraphResult$;
+exports.GetSamplingRules$ = GetSamplingRules$;
 exports.GetSamplingRulesCommand = GetSamplingRulesCommand;
+exports.GetSamplingRulesRequest$ = GetSamplingRulesRequest$;
+exports.GetSamplingRulesResult$ = GetSamplingRulesResult$;
+exports.GetSamplingStatisticSummaries$ = GetSamplingStatisticSummaries$;
 exports.GetSamplingStatisticSummariesCommand = GetSamplingStatisticSummariesCommand;
+exports.GetSamplingStatisticSummariesRequest$ = GetSamplingStatisticSummariesRequest$;
+exports.GetSamplingStatisticSummariesResult$ = GetSamplingStatisticSummariesResult$;
+exports.GetSamplingTargets$ = GetSamplingTargets$;
 exports.GetSamplingTargetsCommand = GetSamplingTargetsCommand;
+exports.GetSamplingTargetsRequest$ = GetSamplingTargetsRequest$;
+exports.GetSamplingTargetsResult$ = GetSamplingTargetsResult$;
+exports.GetServiceGraph$ = GetServiceGraph$;
 exports.GetServiceGraphCommand = GetServiceGraphCommand;
+exports.GetServiceGraphRequest$ = GetServiceGraphRequest$;
+exports.GetServiceGraphResult$ = GetServiceGraphResult$;
+exports.GetTimeSeriesServiceStatistics$ = GetTimeSeriesServiceStatistics$;
 exports.GetTimeSeriesServiceStatisticsCommand = GetTimeSeriesServiceStatisticsCommand;
+exports.GetTimeSeriesServiceStatisticsRequest$ = GetTimeSeriesServiceStatisticsRequest$;
+exports.GetTimeSeriesServiceStatisticsResult$ = GetTimeSeriesServiceStatisticsResult$;
+exports.GetTraceGraph$ = GetTraceGraph$;
 exports.GetTraceGraphCommand = GetTraceGraphCommand;
+exports.GetTraceGraphRequest$ = GetTraceGraphRequest$;
+exports.GetTraceGraphResult$ = GetTraceGraphResult$;
+exports.GetTraceSegmentDestination$ = GetTraceSegmentDestination$;
 exports.GetTraceSegmentDestinationCommand = GetTraceSegmentDestinationCommand;
+exports.GetTraceSegmentDestinationRequest$ = GetTraceSegmentDestinationRequest$;
+exports.GetTraceSegmentDestinationResult$ = GetTraceSegmentDestinationResult$;
+exports.GetTraceSummaries$ = GetTraceSummaries$;
 exports.GetTraceSummariesCommand = GetTraceSummariesCommand;
+exports.GetTraceSummariesRequest$ = GetTraceSummariesRequest$;
+exports.GetTraceSummariesResult$ = GetTraceSummariesResult$;
+exports.GraphLink$ = GraphLink$;
+exports.Group$ = Group$;
+exports.GroupSummary$ = GroupSummary$;
+exports.HistogramEntry$ = HistogramEntry$;
+exports.Http$ = Http$;
+exports.IndexingRule$ = IndexingRule$;
+exports.IndexingRuleValue$ = IndexingRuleValue$;
+exports.IndexingRuleValueUpdate$ = IndexingRuleValueUpdate$;
+exports.Insight$ = Insight$;
 exports.InsightCategory = InsightCategory;
+exports.InsightEvent$ = InsightEvent$;
+exports.InsightImpactGraphEdge$ = InsightImpactGraphEdge$;
+exports.InsightImpactGraphService$ = InsightImpactGraphService$;
 exports.InsightState = InsightState;
+exports.InsightSummary$ = InsightSummary$;
+exports.InsightsConfiguration$ = InsightsConfiguration$;
+exports.InstanceIdDetail$ = InstanceIdDetail$;
+exports.InvalidPolicyRevisionIdException = InvalidPolicyRevisionIdException;
+exports.InvalidPolicyRevisionIdException$ = InvalidPolicyRevisionIdException$;
+exports.InvalidRequestException = InvalidRequestException;
+exports.InvalidRequestException$ = InvalidRequestException$;
+exports.ListResourcePolicies$ = ListResourcePolicies$;
 exports.ListResourcePoliciesCommand = ListResourcePoliciesCommand;
+exports.ListResourcePoliciesRequest$ = ListResourcePoliciesRequest$;
+exports.ListResourcePoliciesResult$ = ListResourcePoliciesResult$;
+exports.ListRetrievedTraces$ = ListRetrievedTraces$;
 exports.ListRetrievedTracesCommand = ListRetrievedTracesCommand;
+exports.ListRetrievedTracesRequest$ = ListRetrievedTracesRequest$;
+exports.ListRetrievedTracesResult$ = ListRetrievedTracesResult$;
+exports.ListTagsForResource$ = ListTagsForResource$;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTagsForResourceRequest$ = ListTagsForResourceRequest$;
+exports.ListTagsForResourceResponse$ = ListTagsForResourceResponse$;
+exports.LockoutPreventionException = LockoutPreventionException;
+exports.LockoutPreventionException$ = LockoutPreventionException$;
+exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException;
+exports.MalformedPolicyDocumentException$ = MalformedPolicyDocumentException$;
+exports.PolicyCountLimitExceededException = PolicyCountLimitExceededException;
+exports.PolicyCountLimitExceededException$ = PolicyCountLimitExceededException$;
+exports.PolicySizeLimitExceededException = PolicySizeLimitExceededException;
+exports.PolicySizeLimitExceededException$ = PolicySizeLimitExceededException$;
+exports.ProbabilisticRuleValue$ = ProbabilisticRuleValue$;
+exports.ProbabilisticRuleValueUpdate$ = ProbabilisticRuleValueUpdate$;
+exports.PutEncryptionConfig$ = PutEncryptionConfig$;
 exports.PutEncryptionConfigCommand = PutEncryptionConfigCommand;
+exports.PutEncryptionConfigRequest$ = PutEncryptionConfigRequest$;
+exports.PutEncryptionConfigResult$ = PutEncryptionConfigResult$;
+exports.PutResourcePolicy$ = PutResourcePolicy$;
 exports.PutResourcePolicyCommand = PutResourcePolicyCommand;
+exports.PutResourcePolicyRequest$ = PutResourcePolicyRequest$;
+exports.PutResourcePolicyResult$ = PutResourcePolicyResult$;
+exports.PutTelemetryRecords$ = PutTelemetryRecords$;
 exports.PutTelemetryRecordsCommand = PutTelemetryRecordsCommand;
+exports.PutTelemetryRecordsRequest$ = PutTelemetryRecordsRequest$;
+exports.PutTelemetryRecordsResult$ = PutTelemetryRecordsResult$;
+exports.PutTraceSegments$ = PutTraceSegments$;
 exports.PutTraceSegmentsCommand = PutTraceSegmentsCommand;
+exports.PutTraceSegmentsRequest$ = PutTraceSegmentsRequest$;
+exports.PutTraceSegmentsResult$ = PutTraceSegmentsResult$;
+exports.RequestImpactStatistics$ = RequestImpactStatistics$;
+exports.ResourceARNDetail$ = ResourceARNDetail$;
+exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException$ = ResourceNotFoundException$;
+exports.ResourcePolicy$ = ResourcePolicy$;
+exports.ResponseTimeRootCause$ = ResponseTimeRootCause$;
+exports.ResponseTimeRootCauseEntity$ = ResponseTimeRootCauseEntity$;
+exports.ResponseTimeRootCauseService$ = ResponseTimeRootCauseService$;
 exports.RetrievalStatus = RetrievalStatus;
+exports.RetrievedService$ = RetrievedService$;
+exports.RetrievedTrace$ = RetrievedTrace$;
+exports.RootCauseException$ = RootCauseException$;
+exports.RuleLimitExceededException = RuleLimitExceededException;
+exports.RuleLimitExceededException$ = RuleLimitExceededException$;
+exports.SamplingBoost$ = SamplingBoost$;
+exports.SamplingBoostStatisticsDocument$ = SamplingBoostStatisticsDocument$;
+exports.SamplingRateBoost$ = SamplingRateBoost$;
+exports.SamplingRule$ = SamplingRule$;
+exports.SamplingRuleRecord$ = SamplingRuleRecord$;
+exports.SamplingRuleUpdate$ = SamplingRuleUpdate$;
+exports.SamplingStatisticSummary$ = SamplingStatisticSummary$;
+exports.SamplingStatisticsDocument$ = SamplingStatisticsDocument$;
+exports.SamplingStrategy$ = SamplingStrategy$;
 exports.SamplingStrategyName = SamplingStrategyName;
+exports.SamplingTargetDocument$ = SamplingTargetDocument$;
+exports.Segment$ = Segment$;
+exports.Service$ = Service$;
+exports.ServiceId$ = ServiceId$;
+exports.ServiceStatistics$ = ServiceStatistics$;
+exports.Span$ = Span$;
+exports.StartTraceRetrieval$ = StartTraceRetrieval$;
 exports.StartTraceRetrievalCommand = StartTraceRetrievalCommand;
+exports.StartTraceRetrievalRequest$ = StartTraceRetrievalRequest$;
+exports.StartTraceRetrievalResult$ = StartTraceRetrievalResult$;
+exports.Tag$ = Tag$;
+exports.TagResource$ = TagResource$;
 exports.TagResourceCommand = TagResourceCommand;
+exports.TagResourceRequest$ = TagResourceRequest$;
+exports.TagResourceResponse$ = TagResourceResponse$;
+exports.TelemetryRecord$ = TelemetryRecord$;
+exports.ThrottledException = ThrottledException;
+exports.ThrottledException$ = ThrottledException$;
 exports.TimeRangeType = TimeRangeType;
+exports.TimeSeriesServiceStatistics$ = TimeSeriesServiceStatistics$;
+exports.TooManyTagsException = TooManyTagsException;
+exports.TooManyTagsException$ = TooManyTagsException$;
+exports.Trace$ = Trace$;
 exports.TraceFormatType = TraceFormatType;
 exports.TraceSegmentDestination = TraceSegmentDestination;
 exports.TraceSegmentDestinationStatus = TraceSegmentDestinationStatus;
+exports.TraceSummary$ = TraceSummary$;
+exports.TraceUser$ = TraceUser$;
+exports.UnprocessedStatistics$ = UnprocessedStatistics$;
+exports.UnprocessedTraceSegment$ = UnprocessedTraceSegment$;
+exports.UntagResource$ = UntagResource$;
 exports.UntagResourceCommand = UntagResourceCommand;
+exports.UntagResourceRequest$ = UntagResourceRequest$;
+exports.UntagResourceResponse$ = UntagResourceResponse$;
+exports.UpdateGroup$ = UpdateGroup$;
 exports.UpdateGroupCommand = UpdateGroupCommand;
+exports.UpdateGroupRequest$ = UpdateGroupRequest$;
+exports.UpdateGroupResult$ = UpdateGroupResult$;
+exports.UpdateIndexingRule$ = UpdateIndexingRule$;
 exports.UpdateIndexingRuleCommand = UpdateIndexingRuleCommand;
+exports.UpdateIndexingRuleRequest$ = UpdateIndexingRuleRequest$;
+exports.UpdateIndexingRuleResult$ = UpdateIndexingRuleResult$;
+exports.UpdateSamplingRule$ = UpdateSamplingRule$;
 exports.UpdateSamplingRuleCommand = UpdateSamplingRuleCommand;
+exports.UpdateSamplingRuleRequest$ = UpdateSamplingRuleRequest$;
+exports.UpdateSamplingRuleResult$ = UpdateSamplingRuleResult$;
+exports.UpdateTraceSegmentDestination$ = UpdateTraceSegmentDestination$;
 exports.UpdateTraceSegmentDestinationCommand = UpdateTraceSegmentDestinationCommand;
+exports.UpdateTraceSegmentDestinationRequest$ = UpdateTraceSegmentDestinationRequest$;
+exports.UpdateTraceSegmentDestinationResult$ = UpdateTraceSegmentDestinationResult$;
+exports.ValueWithServiceIds$ = ValueWithServiceIds$;
 exports.XRay = XRay;
 exports.XRayClient = XRayClient;
+exports.XRayServiceException = XRayServiceException;
+exports.XRayServiceException$ = XRayServiceException$;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateBatchGetTraces = paginateBatchGetTraces;
 exports.paginateGetGroups = paginateGetGroups;
 exports.paginateGetInsightEvents = paginateGetInsightEvents;