@aws-sdk/client-xray 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3281 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XRayServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./XRayClient"), exports);
-tslib_1.__exportStar(require("./XRay"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var XRayServiceException_1 = require("./models/XRayServiceException");
-Object.defineProperty(exports, "XRayServiceException", { enumerable: true, get: function () { return XRayServiceException_1.XRayServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnnotationValue: () => AnnotationValue,
+  BatchGetTracesCommand: () => BatchGetTracesCommand,
+  CreateGroupCommand: () => CreateGroupCommand,
+  CreateSamplingRuleCommand: () => CreateSamplingRuleCommand,
+  DeleteGroupCommand: () => DeleteGroupCommand,
+  DeleteResourcePolicyCommand: () => DeleteResourcePolicyCommand,
+  DeleteSamplingRuleCommand: () => DeleteSamplingRuleCommand,
+  EncryptionStatus: () => EncryptionStatus,
+  EncryptionType: () => EncryptionType,
+  GetEncryptionConfigCommand: () => GetEncryptionConfigCommand,
+  GetGroupCommand: () => GetGroupCommand,
+  GetGroupsCommand: () => GetGroupsCommand,
+  GetInsightCommand: () => GetInsightCommand,
+  GetInsightEventsCommand: () => GetInsightEventsCommand,
+  GetInsightImpactGraphCommand: () => GetInsightImpactGraphCommand,
+  GetInsightSummariesCommand: () => GetInsightSummariesCommand,
+  GetSamplingRulesCommand: () => GetSamplingRulesCommand,
+  GetSamplingStatisticSummariesCommand: () => GetSamplingStatisticSummariesCommand,
+  GetSamplingTargetsCommand: () => GetSamplingTargetsCommand,
+  GetServiceGraphCommand: () => GetServiceGraphCommand,
+  GetTimeSeriesServiceStatisticsCommand: () => GetTimeSeriesServiceStatisticsCommand,
+  GetTraceGraphCommand: () => GetTraceGraphCommand,
+  GetTraceSummariesCommand: () => GetTraceSummariesCommand,
+  InsightCategory: () => InsightCategory,
+  InsightState: () => InsightState,
+  InvalidPolicyRevisionIdException: () => InvalidPolicyRevisionIdException,
+  InvalidRequestException: () => InvalidRequestException,
+  ListResourcePoliciesCommand: () => ListResourcePoliciesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  LockoutPreventionException: () => LockoutPreventionException,
+  MalformedPolicyDocumentException: () => MalformedPolicyDocumentException,
+  PolicyCountLimitExceededException: () => PolicyCountLimitExceededException,
+  PolicySizeLimitExceededException: () => PolicySizeLimitExceededException,
+  PutEncryptionConfigCommand: () => PutEncryptionConfigCommand,
+  PutResourcePolicyCommand: () => PutResourcePolicyCommand,
+  PutTelemetryRecordsCommand: () => PutTelemetryRecordsCommand,
+  PutTraceSegmentsCommand: () => PutTraceSegmentsCommand,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  RuleLimitExceededException: () => RuleLimitExceededException,
+  SamplingStrategyName: () => SamplingStrategyName,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottledException: () => ThrottledException,
+  TimeRangeType: () => TimeRangeType,
+  TooManyTagsException: () => TooManyTagsException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateGroupCommand: () => UpdateGroupCommand,
+  UpdateSamplingRuleCommand: () => UpdateSamplingRuleCommand,
+  XRay: () => XRay,
+  XRayClient: () => XRayClient,
+  XRayServiceException: () => XRayServiceException,
+  __Client: () => import_smithy_client.Client,
+  paginateBatchGetTraces: () => paginateBatchGetTraces,
+  paginateGetGroups: () => paginateGetGroups,
+  paginateGetInsightEvents: () => paginateGetInsightEvents,
+  paginateGetInsightSummaries: () => paginateGetInsightSummaries,
+  paginateGetSamplingRules: () => paginateGetSamplingRules,
+  paginateGetSamplingStatisticSummaries: () => paginateGetSamplingStatisticSummaries,
+  paginateGetServiceGraph: () => paginateGetServiceGraph,
+  paginateGetTimeSeriesServiceStatistics: () => paginateGetTimeSeriesServiceStatistics,
+  paginateGetTraceGraph: () => paginateGetTraceGraph,
+  paginateGetTraceSummaries: () => paginateGetTraceSummaries,
+  paginateListResourcePolicies: () => paginateListResourcePolicies,
+  paginateListTagsForResource: () => paginateListTagsForResource
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/XRayClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "xray"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/XRayClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/XRayClient.ts
+var _XRayClient = class _XRayClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_XRayClient, "XRayClient");
+var XRayClient = _XRayClient;
+
+// src/XRay.ts
+
+
+// src/commands/BatchGetTracesCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@aws-sdk/core");
+var import_core2 = require("@smithy/core");
+
+
+// src/models/XRayServiceException.ts
+
+var _XRayServiceException = class _XRayServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _XRayServiceException.prototype);
+  }
+};
+__name(_XRayServiceException, "XRayServiceException");
+var XRayServiceException = _XRayServiceException;
+
+// src/models/models_0.ts
+var AnnotationValue;
+((AnnotationValue3) => {
+  AnnotationValue3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.NumberValue !== void 0)
+      return visitor.NumberValue(value.NumberValue);
+    if (value.BooleanValue !== void 0)
+      return visitor.BooleanValue(value.BooleanValue);
+    if (value.StringValue !== void 0)
+      return visitor.StringValue(value.StringValue);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AnnotationValue || (AnnotationValue = {}));
+var _InvalidRequestException = class _InvalidRequestException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidRequestException, "InvalidRequestException");
+var InvalidRequestException = _InvalidRequestException;
+var _ThrottledException = class _ThrottledException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottledException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottledException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottledException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ThrottledException, "ThrottledException");
+var ThrottledException = _ThrottledException;
+var _RuleLimitExceededException = class _RuleLimitExceededException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RuleLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RuleLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RuleLimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_RuleLimitExceededException, "RuleLimitExceededException");
+var RuleLimitExceededException = _RuleLimitExceededException;
+var _InvalidPolicyRevisionIdException = class _InvalidPolicyRevisionIdException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidPolicyRevisionIdException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidPolicyRevisionIdException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidPolicyRevisionIdException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidPolicyRevisionIdException, "InvalidPolicyRevisionIdException");
+var InvalidPolicyRevisionIdException = _InvalidPolicyRevisionIdException;
+var EncryptionStatus = {
+  ACTIVE: "ACTIVE",
+  UPDATING: "UPDATING"
+};
+var EncryptionType = {
+  KMS: "KMS",
+  NONE: "NONE"
+};
+var InsightCategory = {
+  FAULT: "FAULT"
+};
+var InsightState = {
+  ACTIVE: "ACTIVE",
+  CLOSED: "CLOSED"
+};
+var SamplingStrategyName = {
+  FixedRate: "FixedRate",
+  PartialScan: "PartialScan"
+};
+var TimeRangeType = {
+  Event: "Event",
+  Service: "Service",
+  TraceId: "TraceId"
+};
+var _ResourceNotFoundException = class _ResourceNotFoundException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _LockoutPreventionException = class _LockoutPreventionException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LockoutPreventionException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LockoutPreventionException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LockoutPreventionException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LockoutPreventionException, "LockoutPreventionException");
+var LockoutPreventionException = _LockoutPreventionException;
+var _MalformedPolicyDocumentException = class _MalformedPolicyDocumentException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MalformedPolicyDocumentException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MalformedPolicyDocumentException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MalformedPolicyDocumentException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_MalformedPolicyDocumentException, "MalformedPolicyDocumentException");
+var MalformedPolicyDocumentException = _MalformedPolicyDocumentException;
+var _PolicyCountLimitExceededException = class _PolicyCountLimitExceededException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PolicyCountLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PolicyCountLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PolicyCountLimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_PolicyCountLimitExceededException, "PolicyCountLimitExceededException");
+var PolicyCountLimitExceededException = _PolicyCountLimitExceededException;
+var _PolicySizeLimitExceededException = class _PolicySizeLimitExceededException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PolicySizeLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PolicySizeLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PolicySizeLimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_PolicySizeLimitExceededException, "PolicySizeLimitExceededException");
+var PolicySizeLimitExceededException = _PolicySizeLimitExceededException;
+var _TooManyTagsException = class _TooManyTagsException extends XRayServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+
+// src/protocols/Aws_restJson1.ts
+var se_BatchGetTracesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/Traces");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      NextToken: [],
+      TraceIds: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchGetTracesCommand");
+var se_CreateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateGroup");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      FilterExpression: [],
+      GroupName: [],
+      InsightsConfiguration: (_) => (0, import_smithy_client._json)(_),
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateGroupCommand");
+var se_CreateSamplingRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateSamplingRule");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      SamplingRule: (_) => se_SamplingRule(_, context),
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateSamplingRuleCommand");
+var se_DeleteGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteGroup");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      GroupARN: [],
+      GroupName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteGroupCommand");
+var se_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteResourcePolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      PolicyName: [],
+      PolicyRevisionId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteResourcePolicyCommand");
+var se_DeleteSamplingRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteSamplingRule");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      RuleARN: [],
+      RuleName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteSamplingRuleCommand");
+var se_GetEncryptionConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/EncryptionConfig");
+  let body;
+  body = "";
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetEncryptionConfigCommand");
+var se_GetGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetGroup");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      GroupARN: [],
+      GroupName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetGroupCommand");
+var se_GetGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/Groups");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetGroupsCommand");
+var se_GetInsightCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/Insight");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      InsightId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetInsightCommand");
+var se_GetInsightEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/InsightEvents");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      InsightId: [],
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetInsightEventsCommand");
+var se_GetInsightImpactGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/InsightImpactGraph");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EndTime: (_) => Math.round(_.getTime() / 1e3),
+      InsightId: [],
+      NextToken: [],
+      StartTime: (_) => Math.round(_.getTime() / 1e3)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetInsightImpactGraphCommand");
+var se_GetInsightSummariesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/InsightSummaries");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EndTime: (_) => Math.round(_.getTime() / 1e3),
+      GroupARN: [],
+      GroupName: [],
+      MaxResults: [],
+      NextToken: [],
+      StartTime: (_) => Math.round(_.getTime() / 1e3),
+      States: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetInsightSummariesCommand");
+var se_GetSamplingRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetSamplingRules");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetSamplingRulesCommand");
+var se_GetSamplingStatisticSummariesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/SamplingStatisticSummaries");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetSamplingStatisticSummariesCommand");
+var se_GetSamplingTargetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/SamplingTargets");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      SamplingStatisticsDocuments: (_) => se_SamplingStatisticsDocumentList(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetSamplingTargetsCommand");
+var se_GetServiceGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ServiceGraph");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EndTime: (_) => Math.round(_.getTime() / 1e3),
+      GroupARN: [],
+      GroupName: [],
+      NextToken: [],
+      StartTime: (_) => Math.round(_.getTime() / 1e3)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetServiceGraphCommand");
+var se_GetTimeSeriesServiceStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/TimeSeriesServiceStatistics");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EndTime: (_) => Math.round(_.getTime() / 1e3),
+      EntitySelectorExpression: [],
+      ForecastStatistics: [],
+      GroupARN: [],
+      GroupName: [],
+      NextToken: [],
+      Period: [],
+      StartTime: (_) => Math.round(_.getTime() / 1e3)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetTimeSeriesServiceStatisticsCommand");
+var se_GetTraceGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/TraceGraph");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      NextToken: [],
+      TraceIds: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetTraceGraphCommand");
+var se_GetTraceSummariesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/TraceSummaries");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EndTime: (_) => Math.round(_.getTime() / 1e3),
+      FilterExpression: [],
+      NextToken: [],
+      Sampling: [],
+      SamplingStrategy: (_) => se_SamplingStrategy(_, context),
+      StartTime: (_) => Math.round(_.getTime() / 1e3),
+      TimeRangeType: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetTraceSummariesCommand");
+var se_ListResourcePoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListResourcePolicies");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListResourcePoliciesCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListTagsForResource");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      NextToken: [],
+      ResourceARN: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_PutEncryptionConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/PutEncryptionConfig");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      KeyId: [],
+      Type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutEncryptionConfigCommand");
+var se_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/PutResourcePolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      BypassPolicyLockoutCheck: [],
+      PolicyDocument: [],
+      PolicyName: [],
+      PolicyRevisionId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutResourcePolicyCommand");
+var se_PutTelemetryRecordsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/TelemetryRecords");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      EC2InstanceId: [],
+      Hostname: [],
+      ResourceARN: [],
+      TelemetryRecords: (_) => se_TelemetryRecordList(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutTelemetryRecordsCommand");
+var se_PutTraceSegmentsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/TraceSegments");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      TraceSegmentDocuments: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutTraceSegmentsCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/TagResource");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ResourceARN: [],
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/UntagResource");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ResourceARN: [],
+      TagKeys: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/UpdateGroup");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      FilterExpression: [],
+      GroupARN: [],
+      GroupName: [],
+      InsightsConfiguration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateGroupCommand");
+var se_UpdateSamplingRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/UpdateSamplingRule");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      SamplingRuleUpdate: (_) => se_SamplingRuleUpdate(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateSamplingRuleCommand");
+var de_BatchGetTracesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchGetTracesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    Traces: (_) => de_TraceList(_, context),
+    UnprocessedTraceIds: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchGetTracesCommand");
+var de_BatchGetTracesCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchGetTracesCommandError");
+var de_CreateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateGroupCommand");
+var de_CreateGroupCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateGroupCommandError");
+var de_CreateSamplingRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateSamplingRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    SamplingRuleRecord: (_) => de_SamplingRuleRecord(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateSamplingRuleCommand");
+var de_CreateSamplingRuleCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "RuleLimitExceededException":
+    case "com.amazonaws.xray#RuleLimitExceededException":
+      throw await de_RuleLimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSamplingRuleCommandError");
+var de_DeleteGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteGroupCommand");
+var de_DeleteGroupCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteGroupCommandError");
+var de_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteResourcePolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteResourcePolicyCommand");
+var de_DeleteResourcePolicyCommandError = /* @__PURE__ */ __name(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 de_InvalidPolicyRevisionIdExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.xray#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteResourcePolicyCommandError");
+var de_DeleteSamplingRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteSamplingRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    SamplingRuleRecord: (_) => de_SamplingRuleRecord(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteSamplingRuleCommand");
+var de_DeleteSamplingRuleCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSamplingRuleCommandError");
+var de_GetEncryptionConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetEncryptionConfigCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EncryptionConfig: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetEncryptionConfigCommand");
+var de_GetEncryptionConfigCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetEncryptionConfigCommandError");
+var de_GetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGroupCommand");
+var de_GetGroupCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGroupCommandError");
+var de_GetGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGroupsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Groups: import_smithy_client._json,
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGroupsCommand");
+var de_GetGroupsCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGroupsCommandError");
+var de_GetInsightCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetInsightCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Insight: (_) => de_Insight(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetInsightCommand");
+var de_GetInsightCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetInsightCommandError");
+var de_GetInsightEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetInsightEventsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    InsightEvents: (_) => de_InsightEventList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetInsightEventsCommand");
+var de_GetInsightEventsCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetInsightEventsCommandError");
+var de_GetInsightImpactGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetInsightImpactGraphCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InsightId: import_smithy_client.expectString,
+    NextToken: import_smithy_client.expectString,
+    ServiceGraphEndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ServiceGraphStartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Services: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetInsightImpactGraphCommand");
+var de_GetInsightImpactGraphCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetInsightImpactGraphCommandError");
+var de_GetInsightSummariesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetInsightSummariesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    InsightSummaries: (_) => de_InsightSummaryList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetInsightSummariesCommand");
+var de_GetInsightSummariesCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetInsightSummariesCommandError");
+var de_GetSamplingRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetSamplingRulesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    SamplingRuleRecords: (_) => de_SamplingRuleRecordList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetSamplingRulesCommand");
+var de_GetSamplingRulesCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSamplingRulesCommandError");
+var de_GetSamplingStatisticSummariesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetSamplingStatisticSummariesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    SamplingStatisticSummaries: (_) => de_SamplingStatisticSummaryList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetSamplingStatisticSummariesCommand");
+var de_GetSamplingStatisticSummariesCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSamplingStatisticSummariesCommandError");
+var de_GetSamplingTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetSamplingTargetsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    LastRuleModification: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SamplingTargetDocuments: (_) => de_SamplingTargetDocumentList(_, context),
+    UnprocessedStatistics: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetSamplingTargetsCommand");
+var de_GetSamplingTargetsCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSamplingTargetsCommandError");
+var de_GetServiceGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetServiceGraphCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ContainsOldGroupVersions: import_smithy_client.expectBoolean,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NextToken: import_smithy_client.expectString,
+    Services: (_) => de_ServiceList(_, context),
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetServiceGraphCommand");
+var de_GetServiceGraphCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetServiceGraphCommandError");
+var de_GetTimeSeriesServiceStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTimeSeriesServiceStatisticsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ContainsOldGroupVersions: import_smithy_client.expectBoolean,
+    NextToken: import_smithy_client.expectString,
+    TimeSeriesServiceStatistics: (_) => de_TimeSeriesServiceStatisticsList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTimeSeriesServiceStatisticsCommand");
+var de_GetTimeSeriesServiceStatisticsCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTimeSeriesServiceStatisticsCommandError");
+var de_GetTraceGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTraceGraphCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    Services: (_) => de_ServiceList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTraceGraphCommand");
+var de_GetTraceGraphCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTraceGraphCommandError");
+var de_GetTraceSummariesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTraceSummariesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ApproximateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NextToken: import_smithy_client.expectString,
+    TraceSummaries: (_) => de_TraceSummaryList(_, context),
+    TracesProcessedCount: import_smithy_client.expectLong
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTraceSummariesCommand");
+var de_GetTraceSummariesCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTraceSummariesCommandError");
+var de_ListResourcePoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListResourcePoliciesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    ResourcePolicies: (_) => de_ResourcePolicyList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListResourcePoliciesCommand");
+var de_ListResourcePoliciesCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListResourcePoliciesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.xray#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_PutEncryptionConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutEncryptionConfigCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EncryptionConfig: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutEncryptionConfigCommand");
+var de_PutEncryptionConfigCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutEncryptionConfigCommandError");
+var de_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutResourcePolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ResourcePolicy: (_) => de_ResourcePolicy(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutResourcePolicyCommand");
+var de_PutResourcePolicyCommandError = /* @__PURE__ */ __name(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 de_InvalidPolicyRevisionIdExceptionRes(parsedOutput, context);
+    case "LockoutPreventionException":
+    case "com.amazonaws.xray#LockoutPreventionException":
+      throw await de_LockoutPreventionExceptionRes(parsedOutput, context);
+    case "MalformedPolicyDocumentException":
+    case "com.amazonaws.xray#MalformedPolicyDocumentException":
+      throw await de_MalformedPolicyDocumentExceptionRes(parsedOutput, context);
+    case "PolicyCountLimitExceededException":
+    case "com.amazonaws.xray#PolicyCountLimitExceededException":
+      throw await de_PolicyCountLimitExceededExceptionRes(parsedOutput, context);
+    case "PolicySizeLimitExceededException":
+    case "com.amazonaws.xray#PolicySizeLimitExceededException":
+      throw await de_PolicySizeLimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutResourcePolicyCommandError");
+var de_PutTelemetryRecordsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutTelemetryRecordsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutTelemetryRecordsCommand");
+var de_PutTelemetryRecordsCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutTelemetryRecordsCommandError");
+var de_PutTraceSegmentsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutTraceSegmentsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    UnprocessedTraceSegments: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutTraceSegmentsCommand");
+var de_PutTraceSegmentsCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutTraceSegmentsCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.xray#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.xray#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.xray#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateGroupCommand");
+var de_UpdateGroupCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateGroupCommandError");
+var de_UpdateSamplingRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateSamplingRuleCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    SamplingRuleRecord: (_) => de_SamplingRuleRecord(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateSamplingRuleCommand");
+var de_UpdateSamplingRuleCommandError = /* @__PURE__ */ __name(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 de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottledException":
+    case "com.amazonaws.xray#ThrottledException":
+      throw await de_ThrottledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSamplingRuleCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(XRayServiceException);
+var de_InvalidPolicyRevisionIdExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidPolicyRevisionIdException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidPolicyRevisionIdExceptionRes");
+var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidRequestExceptionRes");
+var de_LockoutPreventionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new LockoutPreventionException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_LockoutPreventionExceptionRes");
+var de_MalformedPolicyDocumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new MalformedPolicyDocumentException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MalformedPolicyDocumentExceptionRes");
+var de_PolicyCountLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new PolicyCountLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_PolicyCountLimitExceededExceptionRes");
+var de_PolicySizeLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new PolicySizeLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_PolicySizeLimitExceededExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_RuleLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new RuleLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_RuleLimitExceededExceptionRes");
+var de_ThrottledExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottledException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottledExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyTagsExceptionRes");
+var se_SamplingRule = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Attributes: import_smithy_client._json,
+    FixedRate: import_smithy_client.serializeFloat,
+    HTTPMethod: [],
+    Host: [],
+    Priority: [],
+    ReservoirSize: [],
+    ResourceARN: [],
+    RuleARN: [],
+    RuleName: [],
+    ServiceName: [],
+    ServiceType: [],
+    URLPath: [],
+    Version: []
+  });
+}, "se_SamplingRule");
+var se_SamplingRuleUpdate = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Attributes: import_smithy_client._json,
+    FixedRate: import_smithy_client.serializeFloat,
+    HTTPMethod: [],
+    Host: [],
+    Priority: [],
+    ReservoirSize: [],
+    ResourceARN: [],
+    RuleARN: [],
+    RuleName: [],
+    ServiceName: [],
+    ServiceType: [],
+    URLPath: []
+  });
+}, "se_SamplingRuleUpdate");
+var se_SamplingStatisticsDocument = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    BorrowCount: [],
+    ClientID: [],
+    RequestCount: [],
+    RuleName: [],
+    SampledCount: [],
+    Timestamp: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_SamplingStatisticsDocument");
+var se_SamplingStatisticsDocumentList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_SamplingStatisticsDocument(entry, context);
+  });
+}, "se_SamplingStatisticsDocumentList");
+var se_SamplingStrategy = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Name: [],
+    Value: import_smithy_client.serializeFloat
+  });
+}, "se_SamplingStrategy");
+var se_TelemetryRecord = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    BackendConnectionErrors: import_smithy_client._json,
+    SegmentsReceivedCount: [],
+    SegmentsRejectedCount: [],
+    SegmentsSentCount: [],
+    SegmentsSpilloverCount: [],
+    Timestamp: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_TelemetryRecord");
+var se_TelemetryRecordList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_TelemetryRecord(entry, context);
+  });
+}, "se_TelemetryRecordList");
+var de_Annotations = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_ValuesWithServiceIds(value, context);
+    return acc;
+  }, {});
+}, "de_Annotations");
+var de_AnnotationValue = /* @__PURE__ */ __name((output, context) => {
+  if ((0, import_smithy_client.expectBoolean)(output.BooleanValue) !== void 0) {
+    return { BooleanValue: (0, import_smithy_client.expectBoolean)(output.BooleanValue) };
+  }
+  if ((0, import_smithy_client.limitedParseDouble)(output.NumberValue) !== void 0) {
+    return { NumberValue: (0, import_smithy_client.limitedParseDouble)(output.NumberValue) };
+  }
+  if ((0, import_smithy_client.expectString)(output.StringValue) !== void 0) {
+    return { StringValue: (0, import_smithy_client.expectString)(output.StringValue) };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_AnnotationValue");
+var de_Edge = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Aliases: import_smithy_client._json,
+    EdgeType: import_smithy_client.expectString,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ReceivedEventAgeHistogram: (_) => de_Histogram(_, context),
+    ReferenceId: import_smithy_client.expectInt32,
+    ResponseTimeHistogram: (_) => de_Histogram(_, context),
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SummaryStatistics: (_) => de_EdgeStatistics(_, context)
+  });
+}, "de_Edge");
+var de_EdgeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Edge(entry, context);
+  });
+  return retVal;
+}, "de_EdgeList");
+var de_EdgeStatistics = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ErrorStatistics: import_smithy_client._json,
+    FaultStatistics: import_smithy_client._json,
+    OkCount: import_smithy_client.expectLong,
+    TotalCount: import_smithy_client.expectLong,
+    TotalResponseTime: import_smithy_client.limitedParseDouble
+  });
+}, "de_EdgeStatistics");
+var de_Histogram = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_HistogramEntry(entry, context);
+  });
+  return retVal;
+}, "de_Histogram");
+var de_HistogramEntry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Count: import_smithy_client.expectInt32,
+    Value: import_smithy_client.limitedParseDouble
+  });
+}, "de_HistogramEntry");
+var de_Insight = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Categories: import_smithy_client._json,
+    ClientRequestImpactStatistics: import_smithy_client._json,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    GroupARN: import_smithy_client.expectString,
+    GroupName: import_smithy_client.expectString,
+    InsightId: import_smithy_client.expectString,
+    RootCauseServiceId: import_smithy_client._json,
+    RootCauseServiceRequestImpactStatistics: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    State: import_smithy_client.expectString,
+    Summary: import_smithy_client.expectString,
+    TopAnomalousServices: import_smithy_client._json
+  });
+}, "de_Insight");
+var de_InsightEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ClientRequestImpactStatistics: import_smithy_client._json,
+    EventTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    RootCauseServiceRequestImpactStatistics: import_smithy_client._json,
+    Summary: import_smithy_client.expectString,
+    TopAnomalousServices: import_smithy_client._json
+  });
+}, "de_InsightEvent");
+var de_InsightEventList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_InsightEvent(entry, context);
+  });
+  return retVal;
+}, "de_InsightEventList");
+var de_InsightSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Categories: import_smithy_client._json,
+    ClientRequestImpactStatistics: import_smithy_client._json,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    GroupARN: import_smithy_client.expectString,
+    GroupName: import_smithy_client.expectString,
+    InsightId: import_smithy_client.expectString,
+    LastUpdateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    RootCauseServiceId: import_smithy_client._json,
+    RootCauseServiceRequestImpactStatistics: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    State: import_smithy_client.expectString,
+    Summary: import_smithy_client.expectString,
+    TopAnomalousServices: import_smithy_client._json
+  });
+}, "de_InsightSummary");
+var de_InsightSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_InsightSummary(entry, context);
+  });
+  return retVal;
+}, "de_InsightSummaryList");
+var de_ResourcePolicy = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LastUpdatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    PolicyDocument: import_smithy_client.expectString,
+    PolicyName: import_smithy_client.expectString,
+    PolicyRevisionId: import_smithy_client.expectString
+  });
+}, "de_ResourcePolicy");
+var de_ResourcePolicyList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ResourcePolicy(entry, context);
+  });
+  return retVal;
+}, "de_ResourcePolicyList");
+var de_ResponseTimeRootCause = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ClientImpacting: import_smithy_client.expectBoolean,
+    Services: (_) => de_ResponseTimeRootCauseServices(_, context)
+  });
+}, "de_ResponseTimeRootCause");
+var de_ResponseTimeRootCauseEntity = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Coverage: import_smithy_client.limitedParseDouble,
+    Name: import_smithy_client.expectString,
+    Remote: import_smithy_client.expectBoolean
+  });
+}, "de_ResponseTimeRootCauseEntity");
+var de_ResponseTimeRootCauseEntityPath = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ResponseTimeRootCauseEntity(entry, context);
+  });
+  return retVal;
+}, "de_ResponseTimeRootCauseEntityPath");
+var de_ResponseTimeRootCauses = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ResponseTimeRootCause(entry, context);
+  });
+  return retVal;
+}, "de_ResponseTimeRootCauses");
+var de_ResponseTimeRootCauseService = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AccountId: import_smithy_client.expectString,
+    EntityPath: (_) => de_ResponseTimeRootCauseEntityPath(_, context),
+    Inferred: import_smithy_client.expectBoolean,
+    Name: import_smithy_client.expectString,
+    Names: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_ResponseTimeRootCauseService");
+var de_ResponseTimeRootCauseServices = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ResponseTimeRootCauseService(entry, context);
+  });
+  return retVal;
+}, "de_ResponseTimeRootCauseServices");
+var de_SamplingRule = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Attributes: import_smithy_client._json,
+    FixedRate: import_smithy_client.limitedParseDouble,
+    HTTPMethod: import_smithy_client.expectString,
+    Host: import_smithy_client.expectString,
+    Priority: import_smithy_client.expectInt32,
+    ReservoirSize: import_smithy_client.expectInt32,
+    ResourceARN: import_smithy_client.expectString,
+    RuleARN: import_smithy_client.expectString,
+    RuleName: import_smithy_client.expectString,
+    ServiceName: import_smithy_client.expectString,
+    ServiceType: import_smithy_client.expectString,
+    URLPath: import_smithy_client.expectString,
+    Version: import_smithy_client.expectInt32
+  });
+}, "de_SamplingRule");
+var de_SamplingRuleRecord = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ModifiedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SamplingRule: (_) => de_SamplingRule(_, context)
+  });
+}, "de_SamplingRuleRecord");
+var de_SamplingRuleRecordList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SamplingRuleRecord(entry, context);
+  });
+  return retVal;
+}, "de_SamplingRuleRecordList");
+var de_SamplingStatisticSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BorrowCount: import_smithy_client.expectInt32,
+    RequestCount: import_smithy_client.expectInt32,
+    RuleName: import_smithy_client.expectString,
+    SampledCount: import_smithy_client.expectInt32,
+    Timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_SamplingStatisticSummary");
+var de_SamplingStatisticSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SamplingStatisticSummary(entry, context);
+  });
+  return retVal;
+}, "de_SamplingStatisticSummaryList");
+var de_SamplingTargetDocument = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FixedRate: import_smithy_client.limitedParseDouble,
+    Interval: import_smithy_client.expectInt32,
+    ReservoirQuota: import_smithy_client.expectInt32,
+    ReservoirQuotaTTL: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    RuleName: import_smithy_client.expectString
+  });
+}, "de_SamplingTargetDocument");
+var de_SamplingTargetDocumentList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SamplingTargetDocument(entry, context);
+  });
+  return retVal;
+}, "de_SamplingTargetDocumentList");
+var de_Service = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AccountId: import_smithy_client.expectString,
+    DurationHistogram: (_) => de_Histogram(_, context),
+    Edges: (_) => de_EdgeList(_, context),
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString,
+    Names: import_smithy_client._json,
+    ReferenceId: import_smithy_client.expectInt32,
+    ResponseTimeHistogram: (_) => de_Histogram(_, context),
+    Root: import_smithy_client.expectBoolean,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    State: import_smithy_client.expectString,
+    SummaryStatistics: (_) => de_ServiceStatistics(_, context),
+    Type: import_smithy_client.expectString
+  });
+}, "de_Service");
+var de_ServiceList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Service(entry, context);
+  });
+  return retVal;
+}, "de_ServiceList");
+var de_ServiceStatistics = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ErrorStatistics: import_smithy_client._json,
+    FaultStatistics: import_smithy_client._json,
+    OkCount: import_smithy_client.expectLong,
+    TotalCount: import_smithy_client.expectLong,
+    TotalResponseTime: import_smithy_client.limitedParseDouble
+  });
+}, "de_ServiceStatistics");
+var de_TimeSeriesServiceStatistics = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    EdgeSummaryStatistics: (_) => de_EdgeStatistics(_, context),
+    ResponseTimeHistogram: (_) => de_Histogram(_, context),
+    ServiceForecastStatistics: import_smithy_client._json,
+    ServiceSummaryStatistics: (_) => de_ServiceStatistics(_, context),
+    Timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_TimeSeriesServiceStatistics");
+var de_TimeSeriesServiceStatisticsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TimeSeriesServiceStatistics(entry, context);
+  });
+  return retVal;
+}, "de_TimeSeriesServiceStatisticsList");
+var de_Trace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Duration: import_smithy_client.limitedParseDouble,
+    Id: import_smithy_client.expectString,
+    LimitExceeded: import_smithy_client.expectBoolean,
+    Segments: import_smithy_client._json
+  });
+}, "de_Trace");
+var de_TraceList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Trace(entry, context);
+  });
+  return retVal;
+}, "de_TraceList");
+var de_TraceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Annotations: (_) => de_Annotations(_, context),
+    AvailabilityZones: import_smithy_client._json,
+    Duration: import_smithy_client.limitedParseDouble,
+    EntryPoint: import_smithy_client._json,
+    ErrorRootCauses: import_smithy_client._json,
+    FaultRootCauses: import_smithy_client._json,
+    HasError: import_smithy_client.expectBoolean,
+    HasFault: import_smithy_client.expectBoolean,
+    HasThrottle: import_smithy_client.expectBoolean,
+    Http: import_smithy_client._json,
+    Id: import_smithy_client.expectString,
+    InstanceIds: import_smithy_client._json,
+    IsPartial: import_smithy_client.expectBoolean,
+    MatchedEventTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ResourceARNs: import_smithy_client._json,
+    ResponseTime: import_smithy_client.limitedParseDouble,
+    ResponseTimeRootCauses: (_) => de_ResponseTimeRootCauses(_, context),
+    Revision: import_smithy_client.expectInt32,
+    ServiceIds: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Users: import_smithy_client._json
+  });
+}, "de_TraceSummary");
+var de_TraceSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TraceSummary(entry, context);
+  });
+  return retVal;
+}, "de_TraceSummaryList");
+var de_ValuesWithServiceIds = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ValueWithServiceIds(entry, context);
+  });
+  return retVal;
+}, "de_ValuesWithServiceIds");
+var de_ValueWithServiceIds = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnnotationValue: (_) => de_AnnotationValue((0, import_core.awsExpectUnion)(_), context),
+    ServiceIds: import_smithy_client._json
+  });
+}, "de_ValueWithServiceIds");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/BatchGetTracesCommand.ts
+var _BatchGetTracesCommand = class _BatchGetTracesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "BatchGetTraces", {}).n("XRayClient", "BatchGetTracesCommand").f(void 0, void 0).ser(se_BatchGetTracesCommand).de(de_BatchGetTracesCommand).build() {
+};
+__name(_BatchGetTracesCommand, "BatchGetTracesCommand");
+var BatchGetTracesCommand = _BatchGetTracesCommand;
+
+// src/commands/CreateGroupCommand.ts
+
+
+
+
+var _CreateGroupCommand = class _CreateGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "CreateGroup", {}).n("XRayClient", "CreateGroupCommand").f(void 0, void 0).ser(se_CreateGroupCommand).de(de_CreateGroupCommand).build() {
+};
+__name(_CreateGroupCommand, "CreateGroupCommand");
+var CreateGroupCommand = _CreateGroupCommand;
+
+// src/commands/CreateSamplingRuleCommand.ts
+
+
+
+
+var _CreateSamplingRuleCommand = class _CreateSamplingRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "CreateSamplingRule", {}).n("XRayClient", "CreateSamplingRuleCommand").f(void 0, void 0).ser(se_CreateSamplingRuleCommand).de(de_CreateSamplingRuleCommand).build() {
+};
+__name(_CreateSamplingRuleCommand, "CreateSamplingRuleCommand");
+var CreateSamplingRuleCommand = _CreateSamplingRuleCommand;
+
+// src/commands/DeleteGroupCommand.ts
+
+
+
+
+var _DeleteGroupCommand = class _DeleteGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "DeleteGroup", {}).n("XRayClient", "DeleteGroupCommand").f(void 0, void 0).ser(se_DeleteGroupCommand).de(de_DeleteGroupCommand).build() {
+};
+__name(_DeleteGroupCommand, "DeleteGroupCommand");
+var DeleteGroupCommand = _DeleteGroupCommand;
+
+// src/commands/DeleteResourcePolicyCommand.ts
+
+
+
+
+var _DeleteResourcePolicyCommand = class _DeleteResourcePolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "DeleteResourcePolicy", {}).n("XRayClient", "DeleteResourcePolicyCommand").f(void 0, void 0).ser(se_DeleteResourcePolicyCommand).de(de_DeleteResourcePolicyCommand).build() {
+};
+__name(_DeleteResourcePolicyCommand, "DeleteResourcePolicyCommand");
+var DeleteResourcePolicyCommand = _DeleteResourcePolicyCommand;
+
+// src/commands/DeleteSamplingRuleCommand.ts
+
+
+
+
+var _DeleteSamplingRuleCommand = class _DeleteSamplingRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "DeleteSamplingRule", {}).n("XRayClient", "DeleteSamplingRuleCommand").f(void 0, void 0).ser(se_DeleteSamplingRuleCommand).de(de_DeleteSamplingRuleCommand).build() {
+};
+__name(_DeleteSamplingRuleCommand, "DeleteSamplingRuleCommand");
+var DeleteSamplingRuleCommand = _DeleteSamplingRuleCommand;
+
+// src/commands/GetEncryptionConfigCommand.ts
+
+
+
+
+var _GetEncryptionConfigCommand = class _GetEncryptionConfigCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetEncryptionConfig", {}).n("XRayClient", "GetEncryptionConfigCommand").f(void 0, void 0).ser(se_GetEncryptionConfigCommand).de(de_GetEncryptionConfigCommand).build() {
+};
+__name(_GetEncryptionConfigCommand, "GetEncryptionConfigCommand");
+var GetEncryptionConfigCommand = _GetEncryptionConfigCommand;
+
+// src/commands/GetGroupCommand.ts
+
+
+
+
+var _GetGroupCommand = class _GetGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetGroup", {}).n("XRayClient", "GetGroupCommand").f(void 0, void 0).ser(se_GetGroupCommand).de(de_GetGroupCommand).build() {
+};
+__name(_GetGroupCommand, "GetGroupCommand");
+var GetGroupCommand = _GetGroupCommand;
+
+// src/commands/GetGroupsCommand.ts
+
+
+
+
+var _GetGroupsCommand = class _GetGroupsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetGroups", {}).n("XRayClient", "GetGroupsCommand").f(void 0, void 0).ser(se_GetGroupsCommand).de(de_GetGroupsCommand).build() {
+};
+__name(_GetGroupsCommand, "GetGroupsCommand");
+var GetGroupsCommand = _GetGroupsCommand;
+
+// src/commands/GetInsightCommand.ts
+
+
+
+
+var _GetInsightCommand = class _GetInsightCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetInsight", {}).n("XRayClient", "GetInsightCommand").f(void 0, void 0).ser(se_GetInsightCommand).de(de_GetInsightCommand).build() {
+};
+__name(_GetInsightCommand, "GetInsightCommand");
+var GetInsightCommand = _GetInsightCommand;
+
+// src/commands/GetInsightEventsCommand.ts
+
+
+
+
+var _GetInsightEventsCommand = class _GetInsightEventsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetInsightEvents", {}).n("XRayClient", "GetInsightEventsCommand").f(void 0, void 0).ser(se_GetInsightEventsCommand).de(de_GetInsightEventsCommand).build() {
+};
+__name(_GetInsightEventsCommand, "GetInsightEventsCommand");
+var GetInsightEventsCommand = _GetInsightEventsCommand;
+
+// src/commands/GetInsightImpactGraphCommand.ts
+
+
+
+
+var _GetInsightImpactGraphCommand = class _GetInsightImpactGraphCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetInsightImpactGraph", {}).n("XRayClient", "GetInsightImpactGraphCommand").f(void 0, void 0).ser(se_GetInsightImpactGraphCommand).de(de_GetInsightImpactGraphCommand).build() {
+};
+__name(_GetInsightImpactGraphCommand, "GetInsightImpactGraphCommand");
+var GetInsightImpactGraphCommand = _GetInsightImpactGraphCommand;
+
+// src/commands/GetInsightSummariesCommand.ts
+
+
+
+
+var _GetInsightSummariesCommand = class _GetInsightSummariesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetInsightSummaries", {}).n("XRayClient", "GetInsightSummariesCommand").f(void 0, void 0).ser(se_GetInsightSummariesCommand).de(de_GetInsightSummariesCommand).build() {
+};
+__name(_GetInsightSummariesCommand, "GetInsightSummariesCommand");
+var GetInsightSummariesCommand = _GetInsightSummariesCommand;
+
+// src/commands/GetSamplingRulesCommand.ts
+
+
+
+
+var _GetSamplingRulesCommand = class _GetSamplingRulesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetSamplingRules", {}).n("XRayClient", "GetSamplingRulesCommand").f(void 0, void 0).ser(se_GetSamplingRulesCommand).de(de_GetSamplingRulesCommand).build() {
+};
+__name(_GetSamplingRulesCommand, "GetSamplingRulesCommand");
+var GetSamplingRulesCommand = _GetSamplingRulesCommand;
+
+// src/commands/GetSamplingStatisticSummariesCommand.ts
+
+
+
+
+var _GetSamplingStatisticSummariesCommand = class _GetSamplingStatisticSummariesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetSamplingStatisticSummaries", {}).n("XRayClient", "GetSamplingStatisticSummariesCommand").f(void 0, void 0).ser(se_GetSamplingStatisticSummariesCommand).de(de_GetSamplingStatisticSummariesCommand).build() {
+};
+__name(_GetSamplingStatisticSummariesCommand, "GetSamplingStatisticSummariesCommand");
+var GetSamplingStatisticSummariesCommand = _GetSamplingStatisticSummariesCommand;
+
+// src/commands/GetSamplingTargetsCommand.ts
+
+
+
+
+var _GetSamplingTargetsCommand = class _GetSamplingTargetsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetSamplingTargets", {}).n("XRayClient", "GetSamplingTargetsCommand").f(void 0, void 0).ser(se_GetSamplingTargetsCommand).de(de_GetSamplingTargetsCommand).build() {
+};
+__name(_GetSamplingTargetsCommand, "GetSamplingTargetsCommand");
+var GetSamplingTargetsCommand = _GetSamplingTargetsCommand;
+
+// src/commands/GetServiceGraphCommand.ts
+
+
+
+
+var _GetServiceGraphCommand = class _GetServiceGraphCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetServiceGraph", {}).n("XRayClient", "GetServiceGraphCommand").f(void 0, void 0).ser(se_GetServiceGraphCommand).de(de_GetServiceGraphCommand).build() {
+};
+__name(_GetServiceGraphCommand, "GetServiceGraphCommand");
+var GetServiceGraphCommand = _GetServiceGraphCommand;
+
+// src/commands/GetTimeSeriesServiceStatisticsCommand.ts
+
+
+
+
+var _GetTimeSeriesServiceStatisticsCommand = class _GetTimeSeriesServiceStatisticsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetTimeSeriesServiceStatistics", {}).n("XRayClient", "GetTimeSeriesServiceStatisticsCommand").f(void 0, void 0).ser(se_GetTimeSeriesServiceStatisticsCommand).de(de_GetTimeSeriesServiceStatisticsCommand).build() {
+};
+__name(_GetTimeSeriesServiceStatisticsCommand, "GetTimeSeriesServiceStatisticsCommand");
+var GetTimeSeriesServiceStatisticsCommand = _GetTimeSeriesServiceStatisticsCommand;
+
+// src/commands/GetTraceGraphCommand.ts
+
+
+
+
+var _GetTraceGraphCommand = class _GetTraceGraphCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetTraceGraph", {}).n("XRayClient", "GetTraceGraphCommand").f(void 0, void 0).ser(se_GetTraceGraphCommand).de(de_GetTraceGraphCommand).build() {
+};
+__name(_GetTraceGraphCommand, "GetTraceGraphCommand");
+var GetTraceGraphCommand = _GetTraceGraphCommand;
+
+// src/commands/GetTraceSummariesCommand.ts
+
+
+
+
+var _GetTraceSummariesCommand = class _GetTraceSummariesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "GetTraceSummaries", {}).n("XRayClient", "GetTraceSummariesCommand").f(void 0, void 0).ser(se_GetTraceSummariesCommand).de(de_GetTraceSummariesCommand).build() {
+};
+__name(_GetTraceSummariesCommand, "GetTraceSummariesCommand");
+var GetTraceSummariesCommand = _GetTraceSummariesCommand;
+
+// src/commands/ListResourcePoliciesCommand.ts
+
+
+
+
+var _ListResourcePoliciesCommand = class _ListResourcePoliciesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "ListResourcePolicies", {}).n("XRayClient", "ListResourcePoliciesCommand").f(void 0, void 0).ser(se_ListResourcePoliciesCommand).de(de_ListResourcePoliciesCommand).build() {
+};
+__name(_ListResourcePoliciesCommand, "ListResourcePoliciesCommand");
+var ListResourcePoliciesCommand = _ListResourcePoliciesCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "ListTagsForResource", {}).n("XRayClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/PutEncryptionConfigCommand.ts
+
+
+
+
+var _PutEncryptionConfigCommand = class _PutEncryptionConfigCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "PutEncryptionConfig", {}).n("XRayClient", "PutEncryptionConfigCommand").f(void 0, void 0).ser(se_PutEncryptionConfigCommand).de(de_PutEncryptionConfigCommand).build() {
+};
+__name(_PutEncryptionConfigCommand, "PutEncryptionConfigCommand");
+var PutEncryptionConfigCommand = _PutEncryptionConfigCommand;
+
+// src/commands/PutResourcePolicyCommand.ts
+
+
+
+
+var _PutResourcePolicyCommand = class _PutResourcePolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "PutResourcePolicy", {}).n("XRayClient", "PutResourcePolicyCommand").f(void 0, void 0).ser(se_PutResourcePolicyCommand).de(de_PutResourcePolicyCommand).build() {
+};
+__name(_PutResourcePolicyCommand, "PutResourcePolicyCommand");
+var PutResourcePolicyCommand = _PutResourcePolicyCommand;
+
+// src/commands/PutTelemetryRecordsCommand.ts
+
+
+
+
+var _PutTelemetryRecordsCommand = class _PutTelemetryRecordsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "PutTelemetryRecords", {}).n("XRayClient", "PutTelemetryRecordsCommand").f(void 0, void 0).ser(se_PutTelemetryRecordsCommand).de(de_PutTelemetryRecordsCommand).build() {
+};
+__name(_PutTelemetryRecordsCommand, "PutTelemetryRecordsCommand");
+var PutTelemetryRecordsCommand = _PutTelemetryRecordsCommand;
+
+// src/commands/PutTraceSegmentsCommand.ts
+
+
+
+
+var _PutTraceSegmentsCommand = class _PutTraceSegmentsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "PutTraceSegments", {}).n("XRayClient", "PutTraceSegmentsCommand").f(void 0, void 0).ser(se_PutTraceSegmentsCommand).de(de_PutTraceSegmentsCommand).build() {
+};
+__name(_PutTraceSegmentsCommand, "PutTraceSegmentsCommand");
+var PutTraceSegmentsCommand = _PutTraceSegmentsCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "TagResource", {}).n("XRayClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "UntagResource", {}).n("XRayClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateGroupCommand.ts
+
+
+
+
+var _UpdateGroupCommand = class _UpdateGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "UpdateGroup", {}).n("XRayClient", "UpdateGroupCommand").f(void 0, void 0).ser(se_UpdateGroupCommand).de(de_UpdateGroupCommand).build() {
+};
+__name(_UpdateGroupCommand, "UpdateGroupCommand");
+var UpdateGroupCommand = _UpdateGroupCommand;
+
+// src/commands/UpdateSamplingRuleCommand.ts
+
+
+
+
+var _UpdateSamplingRuleCommand = class _UpdateSamplingRuleCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSXRay", "UpdateSamplingRule", {}).n("XRayClient", "UpdateSamplingRuleCommand").f(void 0, void 0).ser(se_UpdateSamplingRuleCommand).de(de_UpdateSamplingRuleCommand).build() {
+};
+__name(_UpdateSamplingRuleCommand, "UpdateSamplingRuleCommand");
+var UpdateSamplingRuleCommand = _UpdateSamplingRuleCommand;
+
+// src/XRay.ts
+var commands = {
+  BatchGetTracesCommand,
+  CreateGroupCommand,
+  CreateSamplingRuleCommand,
+  DeleteGroupCommand,
+  DeleteResourcePolicyCommand,
+  DeleteSamplingRuleCommand,
+  GetEncryptionConfigCommand,
+  GetGroupCommand,
+  GetGroupsCommand,
+  GetInsightCommand,
+  GetInsightEventsCommand,
+  GetInsightImpactGraphCommand,
+  GetInsightSummariesCommand,
+  GetSamplingRulesCommand,
+  GetSamplingStatisticSummariesCommand,
+  GetSamplingTargetsCommand,
+  GetServiceGraphCommand,
+  GetTimeSeriesServiceStatisticsCommand,
+  GetTraceGraphCommand,
+  GetTraceSummariesCommand,
+  ListResourcePoliciesCommand,
+  ListTagsForResourceCommand,
+  PutEncryptionConfigCommand,
+  PutResourcePolicyCommand,
+  PutTelemetryRecordsCommand,
+  PutTraceSegmentsCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateGroupCommand,
+  UpdateSamplingRuleCommand
+};
+var _XRay = class _XRay extends XRayClient {
+};
+__name(_XRay, "XRay");
+var XRay = _XRay;
+(0, import_smithy_client.createAggregatedClient)(commands, XRay);
+
+// src/pagination/BatchGetTracesPaginator.ts
+var import_core3 = require("@smithy/core");
+var paginateBatchGetTraces = (0, import_core3.createPaginator)(XRayClient, BatchGetTracesCommand, "NextToken", "NextToken", "");
+
+// src/pagination/GetGroupsPaginator.ts
+var import_core4 = require("@smithy/core");
+var paginateGetGroups = (0, import_core4.createPaginator)(XRayClient, GetGroupsCommand, "NextToken", "NextToken", "");
+
+// src/pagination/GetInsightEventsPaginator.ts
+var import_core5 = require("@smithy/core");
+var paginateGetInsightEvents = (0, import_core5.createPaginator)(XRayClient, GetInsightEventsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/GetInsightSummariesPaginator.ts
+var import_core6 = require("@smithy/core");
+var paginateGetInsightSummaries = (0, import_core6.createPaginator)(XRayClient, GetInsightSummariesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/GetSamplingRulesPaginator.ts
+var import_core7 = require("@smithy/core");
+var paginateGetSamplingRules = (0, import_core7.createPaginator)(XRayClient, GetSamplingRulesCommand, "NextToken", "NextToken", "");
+
+// src/pagination/GetSamplingStatisticSummariesPaginator.ts
+var import_core8 = require("@smithy/core");
+var paginateGetSamplingStatisticSummaries = (0, import_core8.createPaginator)(XRayClient, GetSamplingStatisticSummariesCommand, "NextToken", "NextToken", "");
+
+// src/pagination/GetServiceGraphPaginator.ts
+var import_core9 = require("@smithy/core");
+var paginateGetServiceGraph = (0, import_core9.createPaginator)(XRayClient, GetServiceGraphCommand, "NextToken", "NextToken", "");
+
+// src/pagination/GetTimeSeriesServiceStatisticsPaginator.ts
+var import_core10 = require("@smithy/core");
+var paginateGetTimeSeriesServiceStatistics = (0, import_core10.createPaginator)(XRayClient, GetTimeSeriesServiceStatisticsCommand, "NextToken", "NextToken", "");
+
+// src/pagination/GetTraceGraphPaginator.ts
+var import_core11 = require("@smithy/core");
+var paginateGetTraceGraph = (0, import_core11.createPaginator)(XRayClient, GetTraceGraphCommand, "NextToken", "NextToken", "");
+
+// src/pagination/GetTraceSummariesPaginator.ts
+var import_core12 = require("@smithy/core");
+var paginateGetTraceSummaries = (0, import_core12.createPaginator)(XRayClient, GetTraceSummariesCommand, "NextToken", "NextToken", "");
+
+// src/pagination/ListResourcePoliciesPaginator.ts
+var import_core13 = require("@smithy/core");
+var paginateListResourcePolicies = (0, import_core13.createPaginator)(XRayClient, ListResourcePoliciesCommand, "NextToken", "NextToken", "");
+
+// src/pagination/ListTagsForResourcePaginator.ts
+var import_core14 = require("@smithy/core");
+var paginateListTagsForResource = (0, import_core14.createPaginator)(XRayClient, ListTagsForResourceCommand, "NextToken", "NextToken", "");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnnotationValue,
+  BatchGetTracesCommand,
+  CreateGroupCommand,
+  CreateSamplingRuleCommand,
+  DeleteGroupCommand,
+  DeleteResourcePolicyCommand,
+  DeleteSamplingRuleCommand,
+  EncryptionStatus,
+  EncryptionType,
+  GetEncryptionConfigCommand,
+  GetGroupCommand,
+  GetGroupsCommand,
+  GetInsightCommand,
+  GetInsightEventsCommand,
+  GetInsightImpactGraphCommand,
+  GetInsightSummariesCommand,
+  GetSamplingRulesCommand,
+  GetSamplingStatisticSummariesCommand,
+  GetSamplingTargetsCommand,
+  GetServiceGraphCommand,
+  GetTimeSeriesServiceStatisticsCommand,
+  GetTraceGraphCommand,
+  GetTraceSummariesCommand,
+  InsightCategory,
+  InsightState,
+  InvalidPolicyRevisionIdException,
+  InvalidRequestException,
+  ListResourcePoliciesCommand,
+  ListTagsForResourceCommand,
+  LockoutPreventionException,
+  MalformedPolicyDocumentException,
+  PolicyCountLimitExceededException,
+  PolicySizeLimitExceededException,
+  PutEncryptionConfigCommand,
+  PutResourcePolicyCommand,
+  PutTelemetryRecordsCommand,
+  PutTraceSegmentsCommand,
+  ResourceNotFoundException,
+  RuleLimitExceededException,
+  SamplingStrategyName,
+  TagResourceCommand,
+  ThrottledException,
+  TimeRangeType,
+  TooManyTagsException,
+  UntagResourceCommand,
+  UpdateGroupCommand,
+  UpdateSamplingRuleCommand,
+  XRay,
+  XRayClient,
+  XRayServiceException,
+  __Client,
+  paginateBatchGetTraces,
+  paginateGetGroups,
+  paginateGetInsightEvents,
+  paginateGetInsightSummaries,
+  paginateGetSamplingRules,
+  paginateGetSamplingStatisticSummaries,
+  paginateGetServiceGraph,
+  paginateGetTimeSeriesServiceStatistics,
+  paginateGetTraceGraph,
+  paginateGetTraceSummaries,
+  paginateListResourcePolicies,
+  paginateListTagsForResource
+});