@aws-sdk/client-xray 3.693.0 → 3.698.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,7 +1,7 @@
 import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
-import { InvalidPolicyRevisionIdException, InvalidRequestException, LockoutPreventionException, MalformedPolicyDocumentException, PolicyCountLimitExceededException, PolicySizeLimitExceededException, ResourceNotFoundException, RuleLimitExceededException, ThrottledException, TooManyTagsException, } from "../models/models_0";
+import { IndexingRuleValueUpdate, InvalidPolicyRevisionIdException, InvalidRequestException, LockoutPreventionException, MalformedPolicyDocumentException, PolicyCountLimitExceededException, PolicySizeLimitExceededException, ResourceNotFoundException, RuleLimitExceededException, ThrottledException, TooManyTagsException, } from "../models/models_0";
 import { XRayServiceException as __BaseException } from "../models/XRayServiceException";
 export const se_BatchGetTracesCommand = async (input, context) => {
     const b = rb(input, context);
@@ -17,6 +17,19 @@ export const se_BatchGetTracesCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_CancelTraceRetrievalCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/CancelTraceRetrieval");
+    let body;
+    body = JSON.stringify(take(input, {
+        RetrievalToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateGroupCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -124,6 +137,19 @@ export const se_GetGroupsCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_GetIndexingRulesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/GetIndexingRules");
+    let body;
+    body = JSON.stringify(take(input, {
+        NextToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_GetInsightCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -187,6 +213,20 @@ export const se_GetInsightSummariesCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_GetRetrievedTracesGraphCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/GetRetrievedTracesGraph");
+    let body;
+    body = JSON.stringify(take(input, {
+        NextToken: [],
+        RetrievalToken: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_GetSamplingRulesCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -277,6 +317,14 @@ export const se_GetTraceGraphCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_GetTraceSegmentDestinationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/GetTraceSegmentDestination");
+    let body;
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_GetTraceSummariesCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -309,6 +357,21 @@ export const se_ListResourcePoliciesCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_ListRetrievedTracesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/ListRetrievedTraces");
+    let body;
+    body = JSON.stringify(take(input, {
+        NextToken: [],
+        RetrievalToken: [],
+        TraceFormat: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_ListTagsForResourceCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -382,6 +445,21 @@ export const se_PutTraceSegmentsCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_StartTraceRetrievalCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/StartTraceRetrieval");
+    let body;
+    body = JSON.stringify(take(input, {
+        EndTime: (_) => _.getTime() / 1000,
+        StartTime: (_) => _.getTime() / 1000,
+        TraceIds: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_TagResourceCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -426,6 +504,20 @@ export const se_UpdateGroupCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_UpdateIndexingRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/UpdateIndexingRule");
+    let body;
+    body = JSON.stringify(take(input, {
+        Name: [],
+        Rule: (_) => se_IndexingRuleValueUpdate(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_UpdateSamplingRuleCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -439,6 +531,19 @@ export const se_UpdateSamplingRuleCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_UpdateTraceSegmentDestinationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/UpdateTraceSegmentDestination");
+    let body;
+    body = JSON.stringify(take(input, {
+        Destination: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const de_BatchGetTracesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -455,6 +560,16 @@ export const de_BatchGetTracesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_CancelTraceRetrievalCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_CreateGroupCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -560,6 +675,21 @@ export const de_GetGroupsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_GetIndexingRulesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        IndexingRules: (_) => de_IndexingRuleList(_, context),
+        NextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetInsightCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -624,6 +754,22 @@ export const de_GetInsightSummariesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_GetRetrievedTracesGraphCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        NextToken: __expectString,
+        RetrievalStatus: __expectString,
+        Services: (_) => de_RetrievedServicesList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetSamplingRulesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -719,6 +865,21 @@ export const de_GetTraceGraphCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_GetTraceSegmentDestinationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Destination: __expectString,
+        Status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetTraceSummariesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -751,6 +912,23 @@ export const de_ListResourcePoliciesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_ListRetrievedTracesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        NextToken: __expectString,
+        RetrievalStatus: __expectString,
+        TraceFormat: __expectString,
+        Traces: (_) => de_TraceSpanList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -818,6 +996,20 @@ export const de_PutTraceSegmentsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_StartTraceRetrievalCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        RetrievalToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -852,6 +1044,20 @@ export const de_UpdateGroupCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_UpdateIndexingRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        IndexingRule: (_) => de_IndexingRule(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_UpdateSamplingRuleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -866,6 +1072,21 @@ export const de_UpdateSamplingRuleCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_UpdateTraceSegmentDestinationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Destination: __expectString,
+        Status: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -879,15 +1100,15 @@ const de_CommandError = async (output, context) => {
         case "ThrottledException":
         case "com.amazonaws.xray#ThrottledException":
             throw await de_ThrottledExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.xray#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "RuleLimitExceededException":
         case "com.amazonaws.xray#RuleLimitExceededException":
             throw await de_RuleLimitExceededExceptionRes(parsedOutput, context);
         case "InvalidPolicyRevisionIdException":
         case "com.amazonaws.xray#InvalidPolicyRevisionIdException":
             throw await de_InvalidPolicyRevisionIdExceptionRes(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.xray#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "LockoutPreventionException":
         case "com.amazonaws.xray#LockoutPreventionException":
             throw await de_LockoutPreventionExceptionRes(parsedOutput, context);
@@ -1045,6 +1266,17 @@ const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const se_IndexingRuleValueUpdate = (input, context) => {
+    return IndexingRuleValueUpdate.visit(input, {
+        Probabilistic: (value) => ({ Probabilistic: se_ProbabilisticRuleValueUpdate(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_ProbabilisticRuleValueUpdate = (input, context) => {
+    return take(input, {
+        DesiredSamplingPercentage: __serializeFloat,
+    });
+};
 const se_SamplingRule = (input, context) => {
     return take(input, {
         Attributes: _json,
@@ -1182,6 +1414,29 @@ const de_HistogramEntry = (output, context) => {
         Value: __limitedParseDouble,
     });
 };
+const de_IndexingRule = (output, context) => {
+    return take(output, {
+        ModifiedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Name: __expectString,
+        Rule: (_) => de_IndexingRuleValue(__expectUnion(_), context),
+    });
+};
+const de_IndexingRuleList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_IndexingRule(entry, context);
+    });
+    return retVal;
+};
+const de_IndexingRuleValue = (output, context) => {
+    if (output.Probabilistic != null) {
+        return {
+            Probabilistic: de_ProbabilisticRuleValue(output.Probabilistic, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
 const de_Insight = (output, context) => {
     return take(output, {
         Categories: _json,
@@ -1240,6 +1495,12 @@ const de_InsightSummaryList = (output, context) => {
     });
     return retVal;
 };
+const de_ProbabilisticRuleValue = (output, context) => {
+    return take(output, {
+        ActualSamplingPercentage: __limitedParseDouble,
+        DesiredSamplingPercentage: __limitedParseDouble,
+    });
+};
 const de_ResourcePolicy = (output, context) => {
     return take(output, {
         LastUpdatedTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
@@ -1303,6 +1564,27 @@ const de_ResponseTimeRootCauseServices = (output, context) => {
     });
     return retVal;
 };
+const de_RetrievedService = (output, context) => {
+    return take(output, {
+        Links: _json,
+        Service: (_) => de_Service(_, context),
+    });
+};
+const de_RetrievedServicesList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_RetrievedService(entry, context);
+    });
+    return retVal;
+};
+const de_RetrievedTrace = (output, context) => {
+    return take(output, {
+        Duration: __limitedParseDouble,
+        Id: __expectString,
+        Spans: _json,
+    });
+};
 const de_SamplingRule = (output, context) => {
     return take(output, {
         Attributes: _json,
@@ -1436,6 +1718,14 @@ const de_TraceList = (output, context) => {
     });
     return retVal;
 };
+const de_TraceSpanList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_RetrievedTrace(entry, context);
+    });
+    return retVal;
+};
 const de_TraceSummary = (output, context) => {
     return take(output, {
         Annotations: (_) => de_Annotations(_, context),

package/dist-types/XRay.d.ts

@@ -1,5 +1,6 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 import { BatchGetTracesCommandInput, BatchGetTracesCommandOutput } from "./commands/BatchGetTracesCommand";
+import { CancelTraceRetrievalCommandInput, CancelTraceRetrievalCommandOutput } from "./commands/CancelTraceRetrievalCommand";
 import { CreateGroupCommandInput, CreateGroupCommandOutput } from "./commands/CreateGroupCommand";
 import { CreateSamplingRuleCommandInput, CreateSamplingRuleCommandOutput } from "./commands/CreateSamplingRuleCommand";
 import { DeleteGroupCommandInput, DeleteGroupCommandOutput } from "./commands/DeleteGroupCommand";
@@ -8,27 +9,34 @@ import { DeleteSamplingRuleCommandInput, DeleteSamplingRuleCommandOutput } from
 import { GetEncryptionConfigCommandInput, GetEncryptionConfigCommandOutput } from "./commands/GetEncryptionConfigCommand";
 import { GetGroupCommandInput, GetGroupCommandOutput } from "./commands/GetGroupCommand";
 import { GetGroupsCommandInput, GetGroupsCommandOutput } from "./commands/GetGroupsCommand";
+import { GetIndexingRulesCommandInput, GetIndexingRulesCommandOutput } from "./commands/GetIndexingRulesCommand";
 import { GetInsightCommandInput, GetInsightCommandOutput } from "./commands/GetInsightCommand";
 import { GetInsightEventsCommandInput, GetInsightEventsCommandOutput } from "./commands/GetInsightEventsCommand";
 import { GetInsightImpactGraphCommandInput, GetInsightImpactGraphCommandOutput } from "./commands/GetInsightImpactGraphCommand";
 import { GetInsightSummariesCommandInput, GetInsightSummariesCommandOutput } from "./commands/GetInsightSummariesCommand";
+import { GetRetrievedTracesGraphCommandInput, GetRetrievedTracesGraphCommandOutput } from "./commands/GetRetrievedTracesGraphCommand";
 import { GetSamplingRulesCommandInput, GetSamplingRulesCommandOutput } from "./commands/GetSamplingRulesCommand";
 import { GetSamplingStatisticSummariesCommandInput, GetSamplingStatisticSummariesCommandOutput } from "./commands/GetSamplingStatisticSummariesCommand";
 import { GetSamplingTargetsCommandInput, GetSamplingTargetsCommandOutput } from "./commands/GetSamplingTargetsCommand";
 import { GetServiceGraphCommandInput, GetServiceGraphCommandOutput } from "./commands/GetServiceGraphCommand";
 import { GetTimeSeriesServiceStatisticsCommandInput, GetTimeSeriesServiceStatisticsCommandOutput } from "./commands/GetTimeSeriesServiceStatisticsCommand";
 import { GetTraceGraphCommandInput, GetTraceGraphCommandOutput } from "./commands/GetTraceGraphCommand";
+import { GetTraceSegmentDestinationCommandInput, GetTraceSegmentDestinationCommandOutput } from "./commands/GetTraceSegmentDestinationCommand";
 import { GetTraceSummariesCommandInput, GetTraceSummariesCommandOutput } from "./commands/GetTraceSummariesCommand";
 import { ListResourcePoliciesCommandInput, ListResourcePoliciesCommandOutput } from "./commands/ListResourcePoliciesCommand";
+import { ListRetrievedTracesCommandInput, ListRetrievedTracesCommandOutput } from "./commands/ListRetrievedTracesCommand";
 import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
 import { PutEncryptionConfigCommandInput, PutEncryptionConfigCommandOutput } from "./commands/PutEncryptionConfigCommand";
 import { PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput } from "./commands/PutResourcePolicyCommand";
 import { PutTelemetryRecordsCommandInput, PutTelemetryRecordsCommandOutput } from "./commands/PutTelemetryRecordsCommand";
 import { PutTraceSegmentsCommandInput, PutTraceSegmentsCommandOutput } from "./commands/PutTraceSegmentsCommand";
+import { StartTraceRetrievalCommandInput, StartTraceRetrievalCommandOutput } from "./commands/StartTraceRetrievalCommand";
 import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { UpdateGroupCommandInput, UpdateGroupCommandOutput } from "./commands/UpdateGroupCommand";
+import { UpdateIndexingRuleCommandInput, UpdateIndexingRuleCommandOutput } from "./commands/UpdateIndexingRuleCommand";
 import { UpdateSamplingRuleCommandInput, UpdateSamplingRuleCommandOutput } from "./commands/UpdateSamplingRuleCommand";
+import { UpdateTraceSegmentDestinationCommandInput, UpdateTraceSegmentDestinationCommandOutput } from "./commands/UpdateTraceSegmentDestinationCommand";
 import { XRayClient } from "./XRayClient";
 export interface XRay {
     /**
@@ -37,6 +45,12 @@ export interface XRay {
     batchGetTraces(args: BatchGetTracesCommandInput, options?: __HttpHandlerOptions): Promise<BatchGetTracesCommandOutput>;
     batchGetTraces(args: BatchGetTracesCommandInput, cb: (err: any, data?: BatchGetTracesCommandOutput) => void): void;
     batchGetTraces(args: BatchGetTracesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchGetTracesCommandOutput) => void): void;
+    /**
+     * @see {@link CancelTraceRetrievalCommand}
+     */
+    cancelTraceRetrieval(args: CancelTraceRetrievalCommandInput, options?: __HttpHandlerOptions): Promise<CancelTraceRetrievalCommandOutput>;
+    cancelTraceRetrieval(args: CancelTraceRetrievalCommandInput, cb: (err: any, data?: CancelTraceRetrievalCommandOutput) => void): void;
+    cancelTraceRetrieval(args: CancelTraceRetrievalCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelTraceRetrievalCommandOutput) => void): void;
     /**
      * @see {@link CreateGroupCommand}
      */
@@ -90,6 +104,13 @@ export interface XRay {
     getGroups(args: GetGroupsCommandInput, options?: __HttpHandlerOptions): Promise<GetGroupsCommandOutput>;
     getGroups(args: GetGroupsCommandInput, cb: (err: any, data?: GetGroupsCommandOutput) => void): void;
     getGroups(args: GetGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetGroupsCommandOutput) => void): void;
+    /**
+     * @see {@link GetIndexingRulesCommand}
+     */
+    getIndexingRules(): Promise<GetIndexingRulesCommandOutput>;
+    getIndexingRules(args: GetIndexingRulesCommandInput, options?: __HttpHandlerOptions): Promise<GetIndexingRulesCommandOutput>;
+    getIndexingRules(args: GetIndexingRulesCommandInput, cb: (err: any, data?: GetIndexingRulesCommandOutput) => void): void;
+    getIndexingRules(args: GetIndexingRulesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetIndexingRulesCommandOutput) => void): void;
     /**
      * @see {@link GetInsightCommand}
      */
@@ -114,6 +135,12 @@ export interface XRay {
     getInsightSummaries(args: GetInsightSummariesCommandInput, options?: __HttpHandlerOptions): Promise<GetInsightSummariesCommandOutput>;
     getInsightSummaries(args: GetInsightSummariesCommandInput, cb: (err: any, data?: GetInsightSummariesCommandOutput) => void): void;
     getInsightSummaries(args: GetInsightSummariesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetInsightSummariesCommandOutput) => void): void;
+    /**
+     * @see {@link GetRetrievedTracesGraphCommand}
+     */
+    getRetrievedTracesGraph(args: GetRetrievedTracesGraphCommandInput, options?: __HttpHandlerOptions): Promise<GetRetrievedTracesGraphCommandOutput>;
+    getRetrievedTracesGraph(args: GetRetrievedTracesGraphCommandInput, cb: (err: any, data?: GetRetrievedTracesGraphCommandOutput) => void): void;
+    getRetrievedTracesGraph(args: GetRetrievedTracesGraphCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetRetrievedTracesGraphCommandOutput) => void): void;
     /**
      * @see {@link GetSamplingRulesCommand}
      */
@@ -152,6 +179,13 @@ export interface XRay {
     getTraceGraph(args: GetTraceGraphCommandInput, options?: __HttpHandlerOptions): Promise<GetTraceGraphCommandOutput>;
     getTraceGraph(args: GetTraceGraphCommandInput, cb: (err: any, data?: GetTraceGraphCommandOutput) => void): void;
     getTraceGraph(args: GetTraceGraphCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTraceGraphCommandOutput) => void): void;
+    /**
+     * @see {@link GetTraceSegmentDestinationCommand}
+     */
+    getTraceSegmentDestination(): Promise<GetTraceSegmentDestinationCommandOutput>;
+    getTraceSegmentDestination(args: GetTraceSegmentDestinationCommandInput, options?: __HttpHandlerOptions): Promise<GetTraceSegmentDestinationCommandOutput>;
+    getTraceSegmentDestination(args: GetTraceSegmentDestinationCommandInput, cb: (err: any, data?: GetTraceSegmentDestinationCommandOutput) => void): void;
+    getTraceSegmentDestination(args: GetTraceSegmentDestinationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTraceSegmentDestinationCommandOutput) => void): void;
     /**
      * @see {@link GetTraceSummariesCommand}
      */
@@ -165,6 +199,12 @@ export interface XRay {
     listResourcePolicies(args: ListResourcePoliciesCommandInput, options?: __HttpHandlerOptions): Promise<ListResourcePoliciesCommandOutput>;
     listResourcePolicies(args: ListResourcePoliciesCommandInput, cb: (err: any, data?: ListResourcePoliciesCommandOutput) => void): void;
     listResourcePolicies(args: ListResourcePoliciesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListResourcePoliciesCommandOutput) => void): void;
+    /**
+     * @see {@link ListRetrievedTracesCommand}
+     */
+    listRetrievedTraces(args: ListRetrievedTracesCommandInput, options?: __HttpHandlerOptions): Promise<ListRetrievedTracesCommandOutput>;
+    listRetrievedTraces(args: ListRetrievedTracesCommandInput, cb: (err: any, data?: ListRetrievedTracesCommandOutput) => void): void;
+    listRetrievedTraces(args: ListRetrievedTracesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListRetrievedTracesCommandOutput) => void): void;
     /**
      * @see {@link ListTagsForResourceCommand}
      */
@@ -195,6 +235,12 @@ export interface XRay {
     putTraceSegments(args: PutTraceSegmentsCommandInput, options?: __HttpHandlerOptions): Promise<PutTraceSegmentsCommandOutput>;
     putTraceSegments(args: PutTraceSegmentsCommandInput, cb: (err: any, data?: PutTraceSegmentsCommandOutput) => void): void;
     putTraceSegments(args: PutTraceSegmentsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutTraceSegmentsCommandOutput) => void): void;
+    /**
+     * @see {@link StartTraceRetrievalCommand}
+     */
+    startTraceRetrieval(args: StartTraceRetrievalCommandInput, options?: __HttpHandlerOptions): Promise<StartTraceRetrievalCommandOutput>;
+    startTraceRetrieval(args: StartTraceRetrievalCommandInput, cb: (err: any, data?: StartTraceRetrievalCommandOutput) => void): void;
+    startTraceRetrieval(args: StartTraceRetrievalCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartTraceRetrievalCommandOutput) => void): void;
     /**
      * @see {@link TagResourceCommand}
      */
@@ -214,12 +260,25 @@ export interface XRay {
     updateGroup(args: UpdateGroupCommandInput, options?: __HttpHandlerOptions): Promise<UpdateGroupCommandOutput>;
     updateGroup(args: UpdateGroupCommandInput, cb: (err: any, data?: UpdateGroupCommandOutput) => void): void;
     updateGroup(args: UpdateGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateGroupCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateIndexingRuleCommand}
+     */
+    updateIndexingRule(args: UpdateIndexingRuleCommandInput, options?: __HttpHandlerOptions): Promise<UpdateIndexingRuleCommandOutput>;
+    updateIndexingRule(args: UpdateIndexingRuleCommandInput, cb: (err: any, data?: UpdateIndexingRuleCommandOutput) => void): void;
+    updateIndexingRule(args: UpdateIndexingRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateIndexingRuleCommandOutput) => void): void;
     /**
      * @see {@link UpdateSamplingRuleCommand}
      */
     updateSamplingRule(args: UpdateSamplingRuleCommandInput, options?: __HttpHandlerOptions): Promise<UpdateSamplingRuleCommandOutput>;
     updateSamplingRule(args: UpdateSamplingRuleCommandInput, cb: (err: any, data?: UpdateSamplingRuleCommandOutput) => void): void;
     updateSamplingRule(args: UpdateSamplingRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateSamplingRuleCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateTraceSegmentDestinationCommand}
+     */
+    updateTraceSegmentDestination(): Promise<UpdateTraceSegmentDestinationCommandOutput>;
+    updateTraceSegmentDestination(args: UpdateTraceSegmentDestinationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTraceSegmentDestinationCommandOutput>;
+    updateTraceSegmentDestination(args: UpdateTraceSegmentDestinationCommandInput, cb: (err: any, data?: UpdateTraceSegmentDestinationCommandOutput) => void): void;
+    updateTraceSegmentDestination(args: UpdateTraceSegmentDestinationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateTraceSegmentDestinationCommandOutput) => void): void;
 }
 /**
  * <p>Amazon Web Services X-Ray provides APIs for managing debug traces and retrieving service maps