@aws-sdk/client-xray 3.211.0 → 3.212.0

package/dist-es/models/models_0.js

@@ -50,6 +50,19 @@ export class RuleLimitExceededException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export class InvalidPolicyRevisionIdException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidPolicyRevisionIdException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidPolicyRevisionIdException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidPolicyRevisionIdException.prototype);
+        this.Message = opts.Message;
+    }
+}
 export var EncryptionStatus;
 (function (EncryptionStatus) {
     EncryptionStatus["ACTIVE"] = "ACTIVE";
@@ -93,6 +106,58 @@ export class ResourceNotFoundException extends __BaseException {
         this.ResourceName = opts.ResourceName;
     }
 }
+export class LockoutPreventionException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "LockoutPreventionException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "LockoutPreventionException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, LockoutPreventionException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class MalformedPolicyDocumentException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "MalformedPolicyDocumentException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "MalformedPolicyDocumentException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class PolicyCountLimitExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "PolicyCountLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "PolicyCountLimitExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, PolicyCountLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class PolicySizeLimitExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "PolicySizeLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "PolicySizeLimitExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, PolicySizeLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
 export class TooManyTagsException extends __BaseException {
     constructor(opts) {
         super({
@@ -178,6 +243,12 @@ export const DeleteGroupRequestFilterSensitiveLog = (obj) => ({
 export const DeleteGroupResultFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const DeleteResourcePolicyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteResourcePolicyResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const DeleteSamplingRuleRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -376,15 +447,21 @@ export const TraceUserFilterSensitiveLog = (obj) => ({
 export const TraceSummaryFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.Annotations && {
-        Annotations: Object.entries(obj.Annotations).reduce((acc, [key, value]) => ({
-            ...acc,
-            [key]: value.map((item) => ValueWithServiceIdsFilterSensitiveLog(item)),
-        }), {}),
+        Annotations: Object.entries(obj.Annotations).reduce((acc, [key, value]) => ((acc[key] = value.map((item) => ValueWithServiceIdsFilterSensitiveLog(item))), acc), {}),
     }),
 });
 export const GetTraceSummariesResultFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const ListResourcePoliciesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ResourcePolicyFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListResourcePoliciesResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const ListTagsForResourceRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -397,6 +474,12 @@ export const PutEncryptionConfigRequestFilterSensitiveLog = (obj) => ({
 export const PutEncryptionConfigResultFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const PutResourcePolicyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutResourcePolicyResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const BackendConnectionErrorsFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/pagination/ListResourcePoliciesPaginator.js

@@ -0,0 +1,31 @@
+import { ListResourcePoliciesCommand, } from "../commands/ListResourcePoliciesCommand";
+import { XRay } from "../XRay";
+import { XRayClient } from "../XRayClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListResourcePoliciesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listResourcePolicies(input, ...args);
+};
+export async function* paginateListResourcePolicies(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        if (config.client instanceof XRay) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof XRayClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected XRay | XRayClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListTagsForResourcePaginator.js

@@ -0,0 +1,31 @@
+import { ListTagsForResourceCommand, } from "../commands/ListTagsForResourceCommand";
+import { XRay } from "../XRay";
+import { XRayClient } from "../XRayClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListTagsForResourceCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listTagsForResource(input, ...args);
+};
+export async function* paginateListTagsForResource(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        if (config.client instanceof XRay) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof XRayClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected XRay | XRayClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -9,3 +9,5 @@ export * from "./GetTimeSeriesServiceStatisticsPaginator";
 export * from "./GetTraceGraphPaginator";
 export * from "./GetTraceSummariesPaginator";
 export * from "./Interfaces";
+export * from "./ListResourcePoliciesPaginator";
+export * from "./ListTagsForResourcePaginator";

package/dist-es/protocols/Aws_restJson1.js

@@ -1,6 +1,6 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, limitedParseDouble as __limitedParseDouble, map as __map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
-import { InvalidRequestException, ResourceNotFoundException, RuleLimitExceededException, ThrottledException, TooManyTagsException, } from "../models/models_0";
+import { InvalidPolicyRevisionIdException, InvalidRequestException, LockoutPreventionException, MalformedPolicyDocumentException, PolicyCountLimitExceededException, PolicySizeLimitExceededException, ResourceNotFoundException, RuleLimitExceededException, ThrottledException, TooManyTagsException, } from "../models/models_0";
 import { XRayServiceException as __BaseException } from "../models/XRayServiceException";
 export const serializeAws_restJson1BatchGetTracesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
@@ -92,6 +92,27 @@ export const serializeAws_restJson1DeleteGroupCommand = async (input, context) =
         body,
     });
 };
+export const serializeAws_restJson1DeleteResourcePolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/DeleteResourcePolicy";
+    let body;
+    body = JSON.stringify({
+        ...(input.PolicyName != null && { PolicyName: input.PolicyName }),
+        ...(input.PolicyRevisionId != null && { PolicyRevisionId: input.PolicyRevisionId }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1DeleteSamplingRuleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -425,6 +446,26 @@ export const serializeAws_restJson1GetTraceSummariesCommand = async (input, cont
         body,
     });
 };
+export const serializeAws_restJson1ListResourcePoliciesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/ListResourcePolicies";
+    let body;
+    body = JSON.stringify({
+        ...(input.NextToken != null && { NextToken: input.NextToken }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -467,6 +508,29 @@ export const serializeAws_restJson1PutEncryptionConfigCommand = async (input, co
         body,
     });
 };
+export const serializeAws_restJson1PutResourcePolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/PutResourcePolicy";
+    let body;
+    body = JSON.stringify({
+        ...(input.BypassPolicyLockoutCheck != null && { BypassPolicyLockoutCheck: input.BypassPolicyLockoutCheck }),
+        ...(input.PolicyDocument != null && { PolicyDocument: input.PolicyDocument }),
+        ...(input.PolicyName != null && { PolicyName: input.PolicyName }),
+        ...(input.PolicyRevisionId != null && { PolicyRevisionId: input.PolicyRevisionId }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1PutTelemetryRecordsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -753,6 +817,42 @@ const deserializeAws_restJson1DeleteGroupCommandError = async (output, context)
             });
     }
 };
+export const deserializeAws_restJson1DeleteResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteResourcePolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidPolicyRevisionIdException":
+        case "com.amazonaws.xray#InvalidPolicyRevisionIdException":
+            throw await deserializeAws_restJson1InvalidPolicyRevisionIdExceptionResponse(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.xray#InvalidRequestException":
+            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+        case "ThrottledException":
+        case "com.amazonaws.xray#ThrottledException":
+            throw await deserializeAws_restJson1ThrottledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1DeleteSamplingRuleCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteSamplingRuleCommandError(output, context);
@@ -1362,6 +1462,45 @@ const deserializeAws_restJson1GetTraceSummariesCommandError = async (output, con
             });
     }
 };
+export const deserializeAws_restJson1ListResourcePoliciesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListResourcePoliciesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.NextToken != null) {
+        contents.NextToken = __expectString(data.NextToken);
+    }
+    if (data.ResourcePolicies != null) {
+        contents.ResourcePolicies = deserializeAws_restJson1ResourcePolicyList(data.ResourcePolicies, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListResourcePoliciesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidRequestException":
+        case "com.amazonaws.xray#InvalidRequestException":
+            throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
+        case "ThrottledException":
+        case "com.amazonaws.xray#ThrottledException":
+            throw await deserializeAws_restJson1ThrottledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
@@ -1440,6 +1579,54 @@ const deserializeAws_restJson1PutEncryptionConfigCommandError = async (output, c
             });
     }
 };
+export const deserializeAws_restJson1PutResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1PutResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.ResourcePolicy != null) {
+        contents.ResourcePolicy = deserializeAws_restJson1ResourcePolicy(data.ResourcePolicy, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1PutResourcePolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidPolicyRevisionIdException":
+        case "com.amazonaws.xray#InvalidPolicyRevisionIdException":
+            throw await deserializeAws_restJson1InvalidPolicyRevisionIdExceptionResponse(parsedOutput, context);
+        case "LockoutPreventionException":
+        case "com.amazonaws.xray#LockoutPreventionException":
+            throw await deserializeAws_restJson1LockoutPreventionExceptionResponse(parsedOutput, context);
+        case "MalformedPolicyDocumentException":
+        case "com.amazonaws.xray#MalformedPolicyDocumentException":
+            throw await deserializeAws_restJson1MalformedPolicyDocumentExceptionResponse(parsedOutput, context);
+        case "PolicyCountLimitExceededException":
+        case "com.amazonaws.xray#PolicyCountLimitExceededException":
+            throw await deserializeAws_restJson1PolicyCountLimitExceededExceptionResponse(parsedOutput, context);
+        case "PolicySizeLimitExceededException":
+        case "com.amazonaws.xray#PolicySizeLimitExceededException":
+            throw await deserializeAws_restJson1PolicySizeLimitExceededExceptionResponse(parsedOutput, context);
+        case "ThrottledException":
+        case "com.amazonaws.xray#ThrottledException":
+            throw await deserializeAws_restJson1ThrottledExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1PutTelemetryRecordsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1PutTelemetryRecordsCommandError(output, context);
@@ -1657,6 +1844,18 @@ const deserializeAws_restJson1UpdateSamplingRuleCommandError = async (output, co
     }
 };
 const map = __map;
+const deserializeAws_restJson1InvalidPolicyRevisionIdExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = __expectString(data.Message);
+    }
+    const exception = new InvalidPolicyRevisionIdException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const deserializeAws_restJson1InvalidRequestExceptionResponse = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -1669,6 +1868,54 @@ const deserializeAws_restJson1InvalidRequestExceptionResponse = async (parsedOut
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const deserializeAws_restJson1LockoutPreventionExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = __expectString(data.Message);
+    }
+    const exception = new LockoutPreventionException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1MalformedPolicyDocumentExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = __expectString(data.Message);
+    }
+    const exception = new MalformedPolicyDocumentException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1PolicyCountLimitExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = __expectString(data.Message);
+    }
+    const exception = new PolicyCountLimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1PolicySizeLimitExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = __expectString(data.Message);
+    }
+    const exception = new PolicySizeLimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -1728,10 +1975,8 @@ const serializeAws_restJson1AttributeMap = (input, context) => {
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: value,
-        };
+        acc[key] = value;
+        return acc;
     }, {});
 };
 const serializeAws_restJson1BackendConnectionErrors = (input, context) => {
@@ -1900,10 +2145,8 @@ const deserializeAws_restJson1Annotations = (output, context) => {
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1ValuesWithServiceIds(value, context),
-        };
+        acc[key] = deserializeAws_restJson1ValuesWithServiceIds(value, context);
+        return acc;
     }, {});
 };
 const deserializeAws_restJson1AnnotationValue = (output, context) => {
@@ -1939,10 +2182,8 @@ const deserializeAws_restJson1AttributeMap = (output, context) => {
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        acc[key] = __expectString(value);
+        return acc;
     }, {});
 };
 const deserializeAws_restJson1AvailabilityZoneDetail = (output, context) => {
@@ -2350,6 +2591,27 @@ const deserializeAws_restJson1ResourceARNDetail = (output, context) => {
         ARN: __expectString(output.ARN),
     };
 };
+const deserializeAws_restJson1ResourcePolicy = (output, context) => {
+    return {
+        LastUpdatedTime: output.LastUpdatedTime != null
+            ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastUpdatedTime)))
+            : undefined,
+        PolicyDocument: __expectString(output.PolicyDocument),
+        PolicyName: __expectString(output.PolicyName),
+        PolicyRevisionId: __expectString(output.PolicyRevisionId),
+    };
+};
+const deserializeAws_restJson1ResourcePolicyList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ResourcePolicy(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1ResponseTimeRootCause = (output, context) => {
     return {
         ClientImpacting: __expectBoolean(output.ClientImpacting),

package/dist-types/XRay.d.ts

@@ -3,6 +3,7 @@ import { BatchGetTracesCommandInput, BatchGetTracesCommandOutput } from "./comma
 import { CreateGroupCommandInput, CreateGroupCommandOutput } from "./commands/CreateGroupCommand";
 import { CreateSamplingRuleCommandInput, CreateSamplingRuleCommandOutput } from "./commands/CreateSamplingRuleCommand";
 import { DeleteGroupCommandInput, DeleteGroupCommandOutput } from "./commands/DeleteGroupCommand";
+import { DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput } from "./commands/DeleteResourcePolicyCommand";
 import { DeleteSamplingRuleCommandInput, DeleteSamplingRuleCommandOutput } from "./commands/DeleteSamplingRuleCommand";
 import { GetEncryptionConfigCommandInput, GetEncryptionConfigCommandOutput } from "./commands/GetEncryptionConfigCommand";
 import { GetGroupCommandInput, GetGroupCommandOutput } from "./commands/GetGroupCommand";
@@ -18,8 +19,10 @@ import { GetServiceGraphCommandInput, GetServiceGraphCommandOutput } from "./com
 import { GetTimeSeriesServiceStatisticsCommandInput, GetTimeSeriesServiceStatisticsCommandOutput } from "./commands/GetTimeSeriesServiceStatisticsCommand";
 import { GetTraceGraphCommandInput, GetTraceGraphCommandOutput } from "./commands/GetTraceGraphCommand";
 import { GetTraceSummariesCommandInput, GetTraceSummariesCommandOutput } from "./commands/GetTraceSummariesCommand";
+import { ListResourcePoliciesCommandInput, ListResourcePoliciesCommandOutput } from "./commands/ListResourcePoliciesCommand";
 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 { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
@@ -64,6 +67,12 @@ export declare class XRay extends XRayClient {
     deleteGroup(args: DeleteGroupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteGroupCommandOutput>;
     deleteGroup(args: DeleteGroupCommandInput, cb: (err: any, data?: DeleteGroupCommandOutput) => void): void;
     deleteGroup(args: DeleteGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteGroupCommandOutput) => void): void;
+    /**
+     * <p>Deletes a resource policy from the target Amazon Web Services account.</p>
+     */
+    deleteResourcePolicy(args: DeleteResourcePolicyCommandInput, options?: __HttpHandlerOptions): Promise<DeleteResourcePolicyCommandOutput>;
+    deleteResourcePolicy(args: DeleteResourcePolicyCommandInput, cb: (err: any, data?: DeleteResourcePolicyCommandOutput) => void): void;
+    deleteResourcePolicy(args: DeleteResourcePolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteResourcePolicyCommandOutput) => void): void;
     /**
      * <p>Deletes a sampling rule.</p>
      */
@@ -181,6 +190,12 @@ export declare class XRay extends XRayClient {
     getTraceSummaries(args: GetTraceSummariesCommandInput, options?: __HttpHandlerOptions): Promise<GetTraceSummariesCommandOutput>;
     getTraceSummaries(args: GetTraceSummariesCommandInput, cb: (err: any, data?: GetTraceSummariesCommandOutput) => void): void;
     getTraceSummaries(args: GetTraceSummariesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTraceSummariesCommandOutput) => void): void;
+    /**
+     * <p>Returns the list of resource policies in the target Amazon Web Services account.</p>
+     */
+    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;
     /**
      * <p>Returns a list of tags that are applied to the specified Amazon Web Services X-Ray group or sampling rule.</p>
      */
@@ -193,6 +208,17 @@ export declare class XRay extends XRayClient {
     putEncryptionConfig(args: PutEncryptionConfigCommandInput, options?: __HttpHandlerOptions): Promise<PutEncryptionConfigCommandOutput>;
     putEncryptionConfig(args: PutEncryptionConfigCommandInput, cb: (err: any, data?: PutEncryptionConfigCommandOutput) => void): void;
     putEncryptionConfig(args: PutEncryptionConfigCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutEncryptionConfigCommandOutput) => void): void;
+    /**
+     * <p>
+     *             Sets the resource policy to grant one or more Amazon Web Services services and accounts permissions to
+     *             access X-Ray. Each resource policy will be associated with a specific Amazon Web Services account.
+     *             Each Amazon Web Services account can have a maximum of 5 resource policies, and each policy name must be
+     *             unique within that account. The maximum size of each resource policy is 5KB.
+     *         </p>
+     */
+    putResourcePolicy(args: PutResourcePolicyCommandInput, options?: __HttpHandlerOptions): Promise<PutResourcePolicyCommandOutput>;
+    putResourcePolicy(args: PutResourcePolicyCommandInput, cb: (err: any, data?: PutResourcePolicyCommandOutput) => void): void;
+    putResourcePolicy(args: PutResourcePolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutResourcePolicyCommandOutput) => void): void;
     /**
      * <p>Used by the Amazon Web Services X-Ray daemon to upload telemetry.</p>
      */