@aws-sdk/client-fis 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,2130 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FisServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./FisClient"), exports);
-tslib_1.__exportStar(require("./Fis"), 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 FisServiceException_1 = require("./models/FisServiceException");
-Object.defineProperty(exports, "FisServiceException", { enumerable: true, get: function () { return FisServiceException_1.FisServiceException; } });
+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, {
+  AccountTargeting: () => AccountTargeting,
+  ConflictException: () => ConflictException,
+  CreateExperimentTemplateCommand: () => CreateExperimentTemplateCommand,
+  CreateTargetAccountConfigurationCommand: () => CreateTargetAccountConfigurationCommand,
+  DeleteExperimentTemplateCommand: () => DeleteExperimentTemplateCommand,
+  DeleteTargetAccountConfigurationCommand: () => DeleteTargetAccountConfigurationCommand,
+  EmptyTargetResolutionMode: () => EmptyTargetResolutionMode,
+  ExperimentActionStatus: () => ExperimentActionStatus,
+  ExperimentStatus: () => ExperimentStatus,
+  Fis: () => Fis,
+  FisClient: () => FisClient,
+  FisServiceException: () => FisServiceException,
+  GetActionCommand: () => GetActionCommand,
+  GetExperimentCommand: () => GetExperimentCommand,
+  GetExperimentTargetAccountConfigurationCommand: () => GetExperimentTargetAccountConfigurationCommand,
+  GetExperimentTemplateCommand: () => GetExperimentTemplateCommand,
+  GetTargetAccountConfigurationCommand: () => GetTargetAccountConfigurationCommand,
+  GetTargetResourceTypeCommand: () => GetTargetResourceTypeCommand,
+  ListActionsCommand: () => ListActionsCommand,
+  ListExperimentResolvedTargetsCommand: () => ListExperimentResolvedTargetsCommand,
+  ListExperimentTargetAccountConfigurationsCommand: () => ListExperimentTargetAccountConfigurationsCommand,
+  ListExperimentTemplatesCommand: () => ListExperimentTemplatesCommand,
+  ListExperimentsCommand: () => ListExperimentsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTargetAccountConfigurationsCommand: () => ListTargetAccountConfigurationsCommand,
+  ListTargetResourceTypesCommand: () => ListTargetResourceTypesCommand,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartExperimentCommand: () => StartExperimentCommand,
+  StopExperimentCommand: () => StopExperimentCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateExperimentTemplateCommand: () => UpdateExperimentTemplateCommand,
+  UpdateTargetAccountConfigurationCommand: () => UpdateTargetAccountConfigurationCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateListActions: () => paginateListActions,
+  paginateListExperimentResolvedTargets: () => paginateListExperimentResolvedTargets,
+  paginateListExperimentTemplates: () => paginateListExperimentTemplates,
+  paginateListExperiments: () => paginateListExperiments,
+  paginateListTargetAccountConfigurations: () => paginateListTargetAccountConfigurations,
+  paginateListTargetResourceTypes: () => paginateListTargetResourceTypes
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/FisClient.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: "fis"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/FisClient.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/FisClient.ts
+var _FisClient = class _FisClient 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(_FisClient, "FisClient");
+var FisClient = _FisClient;
+
+// src/Fis.ts
+
+
+// src/commands/CreateExperimentTemplateCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/FisServiceException.ts
+
+var _FisServiceException = class _FisServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _FisServiceException.prototype);
+  }
+};
+__name(_FisServiceException, "FisServiceException");
+var FisServiceException = _FisServiceException;
+
+// src/models/models_0.ts
+var AccountTargeting = {
+  MULTI_ACCOUNT: "multi-account",
+  SINGLE_ACCOUNT: "single-account"
+};
+var _ConflictException = class _ConflictException extends FisServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var EmptyTargetResolutionMode = {
+  FAIL: "fail",
+  SKIP: "skip"
+};
+var _ResourceNotFoundException = class _ResourceNotFoundException extends FisServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends FisServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _ValidationException = class _ValidationException extends FisServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var ExperimentActionStatus = {
+  cancelled: "cancelled",
+  completed: "completed",
+  failed: "failed",
+  initiating: "initiating",
+  pending: "pending",
+  running: "running",
+  skipped: "skipped",
+  stopped: "stopped",
+  stopping: "stopping"
+};
+var ExperimentStatus = {
+  completed: "completed",
+  failed: "failed",
+  initiating: "initiating",
+  pending: "pending",
+  running: "running",
+  stopped: "stopped",
+  stopping: "stopping"
+};
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateExperimentTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/experimentTemplates");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      actions: (_) => (0, import_smithy_client._json)(_),
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      description: [],
+      experimentOptions: (_) => (0, import_smithy_client._json)(_),
+      logConfiguration: (_) => (0, import_smithy_client._json)(_),
+      roleArn: [],
+      stopConditions: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_),
+      targets: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateExperimentTemplateCommand");
+var se_CreateTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/experimentTemplates/{experimentTemplateId}/targetAccountConfigurations/{accountId}");
+  b.p("experimentTemplateId", () => input.experimentTemplateId, "{experimentTemplateId}", false);
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      description: [],
+      roleArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateTargetAccountConfigurationCommand");
+var se_DeleteExperimentTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experimentTemplates/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteExperimentTemplateCommand");
+var se_DeleteTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experimentTemplates/{experimentTemplateId}/targetAccountConfigurations/{accountId}");
+  b.p("experimentTemplateId", () => input.experimentTemplateId, "{experimentTemplateId}", false);
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTargetAccountConfigurationCommand");
+var se_GetActionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/actions/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetActionCommand");
+var se_GetExperimentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experiments/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetExperimentCommand");
+var se_GetExperimentTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experiments/{experimentId}/targetAccountConfigurations/{accountId}");
+  b.p("experimentId", () => input.experimentId, "{experimentId}", false);
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetExperimentTargetAccountConfigurationCommand");
+var se_GetExperimentTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experimentTemplates/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetExperimentTemplateCommand");
+var se_GetTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experimentTemplates/{experimentTemplateId}/targetAccountConfigurations/{accountId}");
+  b.p("experimentTemplateId", () => input.experimentTemplateId, "{experimentTemplateId}", false);
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTargetAccountConfigurationCommand");
+var se_GetTargetResourceTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/targetResourceTypes/{resourceType}");
+  b.p("resourceType", () => input.resourceType, "{resourceType}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTargetResourceTypeCommand");
+var se_ListActionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/actions");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListActionsCommand");
+var se_ListExperimentResolvedTargetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experiments/{experimentId}/resolvedTargets");
+  b.p("experimentId", () => input.experimentId, "{experimentId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]],
+    [_tN]: [, input[_tN]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListExperimentResolvedTargetsCommand");
+var se_ListExperimentsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experiments");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListExperimentsCommand");
+var se_ListExperimentTargetAccountConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experiments/{experimentId}/targetAccountConfigurations");
+  b.p("experimentId", () => input.experimentId, "{experimentId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListExperimentTargetAccountConfigurationsCommand");
+var se_ListExperimentTemplatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experimentTemplates");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListExperimentTemplatesCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_ListTargetAccountConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experimentTemplates/{experimentTemplateId}/targetAccountConfigurations");
+  b.p("experimentTemplateId", () => input.experimentTemplateId, "{experimentTemplateId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListTargetAccountConfigurationsCommand");
+var se_ListTargetResourceTypesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/targetResourceTypes");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    [_nT]: [, input[_nT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListTargetResourceTypesCommand");
+var se_StartExperimentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/experiments");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      experimentTemplateId: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartExperimentCommand");
+var se_StopExperimentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/experiments/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_StopExperimentCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      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_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [() => input.tagKeys !== void 0, () => (input[_tK] || []).map((_entry) => _entry)]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateExperimentTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/experimentTemplates/{id}");
+  b.p("id", () => input.id, "{id}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      actions: (_) => (0, import_smithy_client._json)(_),
+      description: [],
+      experimentOptions: (_) => (0, import_smithy_client._json)(_),
+      logConfiguration: (_) => (0, import_smithy_client._json)(_),
+      roleArn: [],
+      stopConditions: (_) => (0, import_smithy_client._json)(_),
+      targets: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UpdateExperimentTemplateCommand");
+var se_UpdateTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/experimentTemplates/{experimentTemplateId}/targetAccountConfigurations/{accountId}");
+  b.p("experimentTemplateId", () => input.experimentTemplateId, "{experimentTemplateId}", false);
+  b.p("accountId", () => input.accountId, "{accountId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [],
+      roleArn: []
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UpdateTargetAccountConfigurationCommand");
+var de_CreateExperimentTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateExperimentTemplateCommandError(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, {
+    experimentTemplate: (_) => de_ExperimentTemplate(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateExperimentTemplateCommand");
+var de_CreateExperimentTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.fis#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.fis#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateExperimentTemplateCommandError");
+var de_CreateTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateTargetAccountConfigurationCommandError(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, {
+    targetAccountConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateTargetAccountConfigurationCommand");
+var de_CreateTargetAccountConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.fis#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.fis#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTargetAccountConfigurationCommandError");
+var de_DeleteExperimentTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteExperimentTemplateCommandError(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, {
+    experimentTemplate: (_) => de_ExperimentTemplate(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteExperimentTemplateCommand");
+var de_DeleteExperimentTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteExperimentTemplateCommandError");
+var de_DeleteTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteTargetAccountConfigurationCommandError(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, {
+    targetAccountConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteTargetAccountConfigurationCommand");
+var de_DeleteTargetAccountConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTargetAccountConfigurationCommandError");
+var de_GetActionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetActionCommandError(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, {
+    action: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetActionCommand");
+var de_GetActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetActionCommandError");
+var de_GetExperimentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetExperimentCommandError(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, {
+    experiment: (_) => de_Experiment(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetExperimentCommand");
+var de_GetExperimentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetExperimentCommandError");
+var de_GetExperimentTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetExperimentTargetAccountConfigurationCommandError(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, {
+    targetAccountConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetExperimentTargetAccountConfigurationCommand");
+var de_GetExperimentTargetAccountConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetExperimentTargetAccountConfigurationCommandError");
+var de_GetExperimentTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetExperimentTemplateCommandError(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, {
+    experimentTemplate: (_) => de_ExperimentTemplate(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetExperimentTemplateCommand");
+var de_GetExperimentTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetExperimentTemplateCommandError");
+var de_GetTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTargetAccountConfigurationCommandError(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, {
+    targetAccountConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTargetAccountConfigurationCommand");
+var de_GetTargetAccountConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTargetAccountConfigurationCommandError");
+var de_GetTargetResourceTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTargetResourceTypeCommandError(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, {
+    targetResourceType: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTargetResourceTypeCommand");
+var de_GetTargetResourceTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTargetResourceTypeCommandError");
+var de_ListActionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListActionsCommandError(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, {
+    actions: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListActionsCommand");
+var de_ListActionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListActionsCommandError");
+var de_ListExperimentResolvedTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListExperimentResolvedTargetsCommandError(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,
+    resolvedTargets: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListExperimentResolvedTargetsCommand");
+var de_ListExperimentResolvedTargetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListExperimentResolvedTargetsCommandError");
+var de_ListExperimentsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListExperimentsCommandError(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, {
+    experiments: (_) => de_ExperimentSummaryList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListExperimentsCommand");
+var de_ListExperimentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListExperimentsCommandError");
+var de_ListExperimentTargetAccountConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListExperimentTargetAccountConfigurationsCommandError(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,
+    targetAccountConfigurations: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListExperimentTargetAccountConfigurationsCommand");
+var de_ListExperimentTargetAccountConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListExperimentTargetAccountConfigurationsCommandError");
+var de_ListExperimentTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListExperimentTemplatesCommandError(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, {
+    experimentTemplates: (_) => de_ExperimentTemplateSummaryList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListExperimentTemplatesCommand");
+var de_ListExperimentTemplatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListExperimentTemplatesCommandError");
+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, {
+    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);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_ListTagsForResourceCommandError");
+var de_ListTargetAccountConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTargetAccountConfigurationsCommandError(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,
+    targetAccountConfigurations: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTargetAccountConfigurationsCommand");
+var de_ListTargetAccountConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTargetAccountConfigurationsCommandError");
+var de_ListTargetResourceTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTargetResourceTypesCommandError(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,
+    targetResourceTypes: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTargetResourceTypesCommand");
+var de_ListTargetResourceTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTargetResourceTypesCommandError");
+var de_StartExperimentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartExperimentCommandError(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, {
+    experiment: (_) => de_Experiment(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartExperimentCommand");
+var de_StartExperimentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.fis#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.fis#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartExperimentCommandError");
+var de_StopExperimentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopExperimentCommandError(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, {
+    experiment: (_) => de_Experiment(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StopExperimentCommand");
+var de_StopExperimentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopExperimentCommandError");
+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);
+  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);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_UntagResourceCommandError");
+var de_UpdateExperimentTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateExperimentTemplateCommandError(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, {
+    experimentTemplate: (_) => de_ExperimentTemplate(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateExperimentTemplateCommand");
+var de_UpdateExperimentTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.fis#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateExperimentTemplateCommandError");
+var de_UpdateTargetAccountConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateTargetAccountConfigurationCommandError(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, {
+    targetAccountConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateTargetAccountConfigurationCommand");
+var de_UpdateTargetAccountConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.fis#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.fis#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateTargetAccountConfigurationCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(FisServiceException);
+var de_ConflictExceptionRes = /* @__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 ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+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
+  });
+  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_ServiceQuotaExceededExceptionRes = /* @__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 ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ValidationExceptionRes = /* @__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 ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var de_Experiment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    actions: (_) => de_ExperimentActionMap(_, context),
+    creationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    experimentOptions: import_smithy_client._json,
+    experimentTemplateId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    logConfiguration: import_smithy_client._json,
+    roleArn: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    state: import_smithy_client._json,
+    stopConditions: import_smithy_client._json,
+    tags: import_smithy_client._json,
+    targetAccountConfigurationsCount: import_smithy_client.expectLong,
+    targets: import_smithy_client._json
+  });
+}, "de_Experiment");
+var de_ExperimentAction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    actionId: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    parameters: import_smithy_client._json,
+    startAfter: import_smithy_client._json,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    state: import_smithy_client._json,
+    targets: import_smithy_client._json
+  });
+}, "de_ExperimentAction");
+var de_ExperimentActionMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_ExperimentAction(value, context);
+    return acc;
+  }, {});
+}, "de_ExperimentActionMap");
+var de_ExperimentSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    experimentTemplateId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    state: import_smithy_client._json,
+    tags: import_smithy_client._json
+  });
+}, "de_ExperimentSummary");
+var de_ExperimentSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ExperimentSummary(entry, context);
+  });
+  return retVal;
+}, "de_ExperimentSummaryList");
+var de_ExperimentTemplate = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    actions: import_smithy_client._json,
+    creationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    description: import_smithy_client.expectString,
+    experimentOptions: import_smithy_client._json,
+    id: import_smithy_client.expectString,
+    lastUpdateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    logConfiguration: import_smithy_client._json,
+    roleArn: import_smithy_client.expectString,
+    stopConditions: import_smithy_client._json,
+    tags: import_smithy_client._json,
+    targetAccountConfigurationsCount: import_smithy_client.expectLong,
+    targets: import_smithy_client._json
+  });
+}, "de_ExperimentTemplate");
+var de_ExperimentTemplateSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    lastUpdateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    tags: import_smithy_client._json
+  });
+}, "de_ExperimentTemplateSummary");
+var de_ExperimentTemplateSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ExperimentTemplateSummary(entry, context);
+  });
+  return retVal;
+}, "de_ExperimentTemplateSummaryList");
+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 _mR = "maxResults";
+var _nT = "nextToken";
+var _tK = "tagKeys";
+var _tN = "targetName";
+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/CreateExperimentTemplateCommand.ts
+var _CreateExperimentTemplateCommand = class _CreateExperimentTemplateCommand 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("FaultInjectionSimulator", "CreateExperimentTemplate", {}).n("FisClient", "CreateExperimentTemplateCommand").f(void 0, void 0).ser(se_CreateExperimentTemplateCommand).de(de_CreateExperimentTemplateCommand).build() {
+};
+__name(_CreateExperimentTemplateCommand, "CreateExperimentTemplateCommand");
+var CreateExperimentTemplateCommand = _CreateExperimentTemplateCommand;
+
+// src/commands/CreateTargetAccountConfigurationCommand.ts
+
+
+
+
+var _CreateTargetAccountConfigurationCommand = class _CreateTargetAccountConfigurationCommand 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("FaultInjectionSimulator", "CreateTargetAccountConfiguration", {}).n("FisClient", "CreateTargetAccountConfigurationCommand").f(void 0, void 0).ser(se_CreateTargetAccountConfigurationCommand).de(de_CreateTargetAccountConfigurationCommand).build() {
+};
+__name(_CreateTargetAccountConfigurationCommand, "CreateTargetAccountConfigurationCommand");
+var CreateTargetAccountConfigurationCommand = _CreateTargetAccountConfigurationCommand;
+
+// src/commands/DeleteExperimentTemplateCommand.ts
+
+
+
+
+var _DeleteExperimentTemplateCommand = class _DeleteExperimentTemplateCommand 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("FaultInjectionSimulator", "DeleteExperimentTemplate", {}).n("FisClient", "DeleteExperimentTemplateCommand").f(void 0, void 0).ser(se_DeleteExperimentTemplateCommand).de(de_DeleteExperimentTemplateCommand).build() {
+};
+__name(_DeleteExperimentTemplateCommand, "DeleteExperimentTemplateCommand");
+var DeleteExperimentTemplateCommand = _DeleteExperimentTemplateCommand;
+
+// src/commands/DeleteTargetAccountConfigurationCommand.ts
+
+
+
+
+var _DeleteTargetAccountConfigurationCommand = class _DeleteTargetAccountConfigurationCommand 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("FaultInjectionSimulator", "DeleteTargetAccountConfiguration", {}).n("FisClient", "DeleteTargetAccountConfigurationCommand").f(void 0, void 0).ser(se_DeleteTargetAccountConfigurationCommand).de(de_DeleteTargetAccountConfigurationCommand).build() {
+};
+__name(_DeleteTargetAccountConfigurationCommand, "DeleteTargetAccountConfigurationCommand");
+var DeleteTargetAccountConfigurationCommand = _DeleteTargetAccountConfigurationCommand;
+
+// src/commands/GetActionCommand.ts
+
+
+
+
+var _GetActionCommand = class _GetActionCommand 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("FaultInjectionSimulator", "GetAction", {}).n("FisClient", "GetActionCommand").f(void 0, void 0).ser(se_GetActionCommand).de(de_GetActionCommand).build() {
+};
+__name(_GetActionCommand, "GetActionCommand");
+var GetActionCommand = _GetActionCommand;
+
+// src/commands/GetExperimentCommand.ts
+
+
+
+
+var _GetExperimentCommand = class _GetExperimentCommand 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("FaultInjectionSimulator", "GetExperiment", {}).n("FisClient", "GetExperimentCommand").f(void 0, void 0).ser(se_GetExperimentCommand).de(de_GetExperimentCommand).build() {
+};
+__name(_GetExperimentCommand, "GetExperimentCommand");
+var GetExperimentCommand = _GetExperimentCommand;
+
+// src/commands/GetExperimentTargetAccountConfigurationCommand.ts
+
+
+
+
+var _GetExperimentTargetAccountConfigurationCommand = class _GetExperimentTargetAccountConfigurationCommand 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("FaultInjectionSimulator", "GetExperimentTargetAccountConfiguration", {}).n("FisClient", "GetExperimentTargetAccountConfigurationCommand").f(void 0, void 0).ser(se_GetExperimentTargetAccountConfigurationCommand).de(de_GetExperimentTargetAccountConfigurationCommand).build() {
+};
+__name(_GetExperimentTargetAccountConfigurationCommand, "GetExperimentTargetAccountConfigurationCommand");
+var GetExperimentTargetAccountConfigurationCommand = _GetExperimentTargetAccountConfigurationCommand;
+
+// src/commands/GetExperimentTemplateCommand.ts
+
+
+
+
+var _GetExperimentTemplateCommand = class _GetExperimentTemplateCommand 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("FaultInjectionSimulator", "GetExperimentTemplate", {}).n("FisClient", "GetExperimentTemplateCommand").f(void 0, void 0).ser(se_GetExperimentTemplateCommand).de(de_GetExperimentTemplateCommand).build() {
+};
+__name(_GetExperimentTemplateCommand, "GetExperimentTemplateCommand");
+var GetExperimentTemplateCommand = _GetExperimentTemplateCommand;
+
+// src/commands/GetTargetAccountConfigurationCommand.ts
+
+
+
+
+var _GetTargetAccountConfigurationCommand = class _GetTargetAccountConfigurationCommand 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("FaultInjectionSimulator", "GetTargetAccountConfiguration", {}).n("FisClient", "GetTargetAccountConfigurationCommand").f(void 0, void 0).ser(se_GetTargetAccountConfigurationCommand).de(de_GetTargetAccountConfigurationCommand).build() {
+};
+__name(_GetTargetAccountConfigurationCommand, "GetTargetAccountConfigurationCommand");
+var GetTargetAccountConfigurationCommand = _GetTargetAccountConfigurationCommand;
+
+// src/commands/GetTargetResourceTypeCommand.ts
+
+
+
+
+var _GetTargetResourceTypeCommand = class _GetTargetResourceTypeCommand 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("FaultInjectionSimulator", "GetTargetResourceType", {}).n("FisClient", "GetTargetResourceTypeCommand").f(void 0, void 0).ser(se_GetTargetResourceTypeCommand).de(de_GetTargetResourceTypeCommand).build() {
+};
+__name(_GetTargetResourceTypeCommand, "GetTargetResourceTypeCommand");
+var GetTargetResourceTypeCommand = _GetTargetResourceTypeCommand;
+
+// src/commands/ListActionsCommand.ts
+
+
+
+
+var _ListActionsCommand = class _ListActionsCommand 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("FaultInjectionSimulator", "ListActions", {}).n("FisClient", "ListActionsCommand").f(void 0, void 0).ser(se_ListActionsCommand).de(de_ListActionsCommand).build() {
+};
+__name(_ListActionsCommand, "ListActionsCommand");
+var ListActionsCommand = _ListActionsCommand;
+
+// src/commands/ListExperimentResolvedTargetsCommand.ts
+
+
+
+
+var _ListExperimentResolvedTargetsCommand = class _ListExperimentResolvedTargetsCommand 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("FaultInjectionSimulator", "ListExperimentResolvedTargets", {}).n("FisClient", "ListExperimentResolvedTargetsCommand").f(void 0, void 0).ser(se_ListExperimentResolvedTargetsCommand).de(de_ListExperimentResolvedTargetsCommand).build() {
+};
+__name(_ListExperimentResolvedTargetsCommand, "ListExperimentResolvedTargetsCommand");
+var ListExperimentResolvedTargetsCommand = _ListExperimentResolvedTargetsCommand;
+
+// src/commands/ListExperimentsCommand.ts
+
+
+
+
+var _ListExperimentsCommand = class _ListExperimentsCommand 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("FaultInjectionSimulator", "ListExperiments", {}).n("FisClient", "ListExperimentsCommand").f(void 0, void 0).ser(se_ListExperimentsCommand).de(de_ListExperimentsCommand).build() {
+};
+__name(_ListExperimentsCommand, "ListExperimentsCommand");
+var ListExperimentsCommand = _ListExperimentsCommand;
+
+// src/commands/ListExperimentTargetAccountConfigurationsCommand.ts
+
+
+
+
+var _ListExperimentTargetAccountConfigurationsCommand = class _ListExperimentTargetAccountConfigurationsCommand 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("FaultInjectionSimulator", "ListExperimentTargetAccountConfigurations", {}).n("FisClient", "ListExperimentTargetAccountConfigurationsCommand").f(void 0, void 0).ser(se_ListExperimentTargetAccountConfigurationsCommand).de(de_ListExperimentTargetAccountConfigurationsCommand).build() {
+};
+__name(_ListExperimentTargetAccountConfigurationsCommand, "ListExperimentTargetAccountConfigurationsCommand");
+var ListExperimentTargetAccountConfigurationsCommand = _ListExperimentTargetAccountConfigurationsCommand;
+
+// src/commands/ListExperimentTemplatesCommand.ts
+
+
+
+
+var _ListExperimentTemplatesCommand = class _ListExperimentTemplatesCommand 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("FaultInjectionSimulator", "ListExperimentTemplates", {}).n("FisClient", "ListExperimentTemplatesCommand").f(void 0, void 0).ser(se_ListExperimentTemplatesCommand).de(de_ListExperimentTemplatesCommand).build() {
+};
+__name(_ListExperimentTemplatesCommand, "ListExperimentTemplatesCommand");
+var ListExperimentTemplatesCommand = _ListExperimentTemplatesCommand;
+
+// 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("FaultInjectionSimulator", "ListTagsForResource", {}).n("FisClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListTargetAccountConfigurationsCommand.ts
+
+
+
+
+var _ListTargetAccountConfigurationsCommand = class _ListTargetAccountConfigurationsCommand 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("FaultInjectionSimulator", "ListTargetAccountConfigurations", {}).n("FisClient", "ListTargetAccountConfigurationsCommand").f(void 0, void 0).ser(se_ListTargetAccountConfigurationsCommand).de(de_ListTargetAccountConfigurationsCommand).build() {
+};
+__name(_ListTargetAccountConfigurationsCommand, "ListTargetAccountConfigurationsCommand");
+var ListTargetAccountConfigurationsCommand = _ListTargetAccountConfigurationsCommand;
+
+// src/commands/ListTargetResourceTypesCommand.ts
+
+
+
+
+var _ListTargetResourceTypesCommand = class _ListTargetResourceTypesCommand 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("FaultInjectionSimulator", "ListTargetResourceTypes", {}).n("FisClient", "ListTargetResourceTypesCommand").f(void 0, void 0).ser(se_ListTargetResourceTypesCommand).de(de_ListTargetResourceTypesCommand).build() {
+};
+__name(_ListTargetResourceTypesCommand, "ListTargetResourceTypesCommand");
+var ListTargetResourceTypesCommand = _ListTargetResourceTypesCommand;
+
+// src/commands/StartExperimentCommand.ts
+
+
+
+
+var _StartExperimentCommand = class _StartExperimentCommand 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("FaultInjectionSimulator", "StartExperiment", {}).n("FisClient", "StartExperimentCommand").f(void 0, void 0).ser(se_StartExperimentCommand).de(de_StartExperimentCommand).build() {
+};
+__name(_StartExperimentCommand, "StartExperimentCommand");
+var StartExperimentCommand = _StartExperimentCommand;
+
+// src/commands/StopExperimentCommand.ts
+
+
+
+
+var _StopExperimentCommand = class _StopExperimentCommand 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("FaultInjectionSimulator", "StopExperiment", {}).n("FisClient", "StopExperimentCommand").f(void 0, void 0).ser(se_StopExperimentCommand).de(de_StopExperimentCommand).build() {
+};
+__name(_StopExperimentCommand, "StopExperimentCommand");
+var StopExperimentCommand = _StopExperimentCommand;
+
+// 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("FaultInjectionSimulator", "TagResource", {}).n("FisClient", "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("FaultInjectionSimulator", "UntagResource", {}).n("FisClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateExperimentTemplateCommand.ts
+
+
+
+
+var _UpdateExperimentTemplateCommand = class _UpdateExperimentTemplateCommand 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("FaultInjectionSimulator", "UpdateExperimentTemplate", {}).n("FisClient", "UpdateExperimentTemplateCommand").f(void 0, void 0).ser(se_UpdateExperimentTemplateCommand).de(de_UpdateExperimentTemplateCommand).build() {
+};
+__name(_UpdateExperimentTemplateCommand, "UpdateExperimentTemplateCommand");
+var UpdateExperimentTemplateCommand = _UpdateExperimentTemplateCommand;
+
+// src/commands/UpdateTargetAccountConfigurationCommand.ts
+
+
+
+
+var _UpdateTargetAccountConfigurationCommand = class _UpdateTargetAccountConfigurationCommand 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("FaultInjectionSimulator", "UpdateTargetAccountConfiguration", {}).n("FisClient", "UpdateTargetAccountConfigurationCommand").f(void 0, void 0).ser(se_UpdateTargetAccountConfigurationCommand).de(de_UpdateTargetAccountConfigurationCommand).build() {
+};
+__name(_UpdateTargetAccountConfigurationCommand, "UpdateTargetAccountConfigurationCommand");
+var UpdateTargetAccountConfigurationCommand = _UpdateTargetAccountConfigurationCommand;
+
+// src/Fis.ts
+var commands = {
+  CreateExperimentTemplateCommand,
+  CreateTargetAccountConfigurationCommand,
+  DeleteExperimentTemplateCommand,
+  DeleteTargetAccountConfigurationCommand,
+  GetActionCommand,
+  GetExperimentCommand,
+  GetExperimentTargetAccountConfigurationCommand,
+  GetExperimentTemplateCommand,
+  GetTargetAccountConfigurationCommand,
+  GetTargetResourceTypeCommand,
+  ListActionsCommand,
+  ListExperimentResolvedTargetsCommand,
+  ListExperimentsCommand,
+  ListExperimentTargetAccountConfigurationsCommand,
+  ListExperimentTemplatesCommand,
+  ListTagsForResourceCommand,
+  ListTargetAccountConfigurationsCommand,
+  ListTargetResourceTypesCommand,
+  StartExperimentCommand,
+  StopExperimentCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateExperimentTemplateCommand,
+  UpdateTargetAccountConfigurationCommand
+};
+var _Fis = class _Fis extends FisClient {
+};
+__name(_Fis, "Fis");
+var Fis = _Fis;
+(0, import_smithy_client.createAggregatedClient)(commands, Fis);
+
+// src/pagination/ListActionsPaginator.ts
+
+var paginateListActions = (0, import_core.createPaginator)(FisClient, ListActionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListExperimentResolvedTargetsPaginator.ts
+
+var paginateListExperimentResolvedTargets = (0, import_core.createPaginator)(FisClient, ListExperimentResolvedTargetsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListExperimentTemplatesPaginator.ts
+
+var paginateListExperimentTemplates = (0, import_core.createPaginator)(FisClient, ListExperimentTemplatesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListExperimentsPaginator.ts
+
+var paginateListExperiments = (0, import_core.createPaginator)(FisClient, ListExperimentsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTargetAccountConfigurationsPaginator.ts
+
+var paginateListTargetAccountConfigurations = (0, import_core.createPaginator)(FisClient, ListTargetAccountConfigurationsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTargetResourceTypesPaginator.ts
+
+var paginateListTargetResourceTypes = (0, import_core.createPaginator)(FisClient, ListTargetResourceTypesCommand, "nextToken", "nextToken", "maxResults");
+
+// 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 = {
+  AccountTargeting,
+  ConflictException,
+  CreateExperimentTemplateCommand,
+  CreateTargetAccountConfigurationCommand,
+  DeleteExperimentTemplateCommand,
+  DeleteTargetAccountConfigurationCommand,
+  EmptyTargetResolutionMode,
+  ExperimentActionStatus,
+  ExperimentStatus,
+  Fis,
+  FisClient,
+  FisServiceException,
+  GetActionCommand,
+  GetExperimentCommand,
+  GetExperimentTargetAccountConfigurationCommand,
+  GetExperimentTemplateCommand,
+  GetTargetAccountConfigurationCommand,
+  GetTargetResourceTypeCommand,
+  ListActionsCommand,
+  ListExperimentResolvedTargetsCommand,
+  ListExperimentTargetAccountConfigurationsCommand,
+  ListExperimentTemplatesCommand,
+  ListExperimentsCommand,
+  ListTagsForResourceCommand,
+  ListTargetAccountConfigurationsCommand,
+  ListTargetResourceTypesCommand,
+  ResourceNotFoundException,
+  ServiceQuotaExceededException,
+  StartExperimentCommand,
+  StopExperimentCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateExperimentTemplateCommand,
+  UpdateTargetAccountConfigurationCommand,
+  ValidationException,
+  __Client,
+  paginateListActions,
+  paginateListExperimentResolvedTargets,
+  paginateListExperimentTemplates,
+  paginateListExperiments,
+  paginateListTargetAccountConfigurations,
+  paginateListTargetResourceTypes
+});