@aws-sdk/client-synthetics 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,2296 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyntheticsServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SyntheticsClient"), exports);
-tslib_1.__exportStar(require("./Synthetics"), 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 SyntheticsServiceException_1 = require("./models/SyntheticsServiceException");
-Object.defineProperty(exports, "SyntheticsServiceException", { enumerable: true, get: function () { return SyntheticsServiceException_1.SyntheticsServiceException; } });
+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, {
+  AssociateResourceCommand: () => AssociateResourceCommand,
+  BadRequestException: () => BadRequestException,
+  CanaryRunState: () => CanaryRunState,
+  CanaryRunStateReasonCode: () => CanaryRunStateReasonCode,
+  CanaryState: () => CanaryState,
+  CanaryStateReasonCode: () => CanaryStateReasonCode,
+  ConflictException: () => ConflictException,
+  CreateCanaryCommand: () => CreateCanaryCommand,
+  CreateGroupCommand: () => CreateGroupCommand,
+  DeleteCanaryCommand: () => DeleteCanaryCommand,
+  DeleteGroupCommand: () => DeleteGroupCommand,
+  DescribeCanariesCommand: () => DescribeCanariesCommand,
+  DescribeCanariesLastRunCommand: () => DescribeCanariesLastRunCommand,
+  DescribeRuntimeVersionsCommand: () => DescribeRuntimeVersionsCommand,
+  DisassociateResourceCommand: () => DisassociateResourceCommand,
+  EncryptionMode: () => EncryptionMode,
+  GetCanaryCommand: () => GetCanaryCommand,
+  GetCanaryRunsCommand: () => GetCanaryRunsCommand,
+  GetGroupCommand: () => GetGroupCommand,
+  InternalFailureException: () => InternalFailureException,
+  InternalServerException: () => InternalServerException,
+  ListAssociatedGroupsCommand: () => ListAssociatedGroupsCommand,
+  ListGroupResourcesCommand: () => ListGroupResourcesCommand,
+  ListGroupsCommand: () => ListGroupsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  NotFoundException: () => NotFoundException,
+  RequestEntityTooLargeException: () => RequestEntityTooLargeException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartCanaryCommand: () => StartCanaryCommand,
+  StopCanaryCommand: () => StopCanaryCommand,
+  Synthetics: () => Synthetics,
+  SyntheticsClient: () => SyntheticsClient,
+  SyntheticsServiceException: () => SyntheticsServiceException,
+  TagResourceCommand: () => TagResourceCommand,
+  TooManyRequestsException: () => TooManyRequestsException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateCanaryCommand: () => UpdateCanaryCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeCanaries: () => paginateDescribeCanaries,
+  paginateDescribeCanariesLastRun: () => paginateDescribeCanariesLastRun,
+  paginateDescribeRuntimeVersions: () => paginateDescribeRuntimeVersions,
+  paginateGetCanaryRuns: () => paginateGetCanaryRuns,
+  paginateListAssociatedGroups: () => paginateListAssociatedGroups,
+  paginateListGroupResources: () => paginateListGroupResources,
+  paginateListGroups: () => paginateListGroups
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SyntheticsClient.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: "synthetics"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/SyntheticsClient.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/SyntheticsClient.ts
+var _SyntheticsClient = class _SyntheticsClient 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(_SyntheticsClient, "SyntheticsClient");
+var SyntheticsClient = _SyntheticsClient;
+
+// src/Synthetics.ts
+
+
+// src/commands/AssociateResourceCommand.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");
+
+
+// src/models/SyntheticsServiceException.ts
+
+var _SyntheticsServiceException = class _SyntheticsServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SyntheticsServiceException.prototype);
+  }
+};
+__name(_SyntheticsServiceException, "SyntheticsServiceException");
+var SyntheticsServiceException = _SyntheticsServiceException;
+
+// src/models/models_0.ts
+var EncryptionMode = {
+  SSE_KMS: "SSE_KMS",
+  SSE_S3: "SSE_S3"
+};
+var _ConflictException = class _ConflictException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalServerException = class _InternalServerException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _ValidationException = class _ValidationException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _BadRequestException = class _BadRequestException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var CanaryState = {
+  CREATING: "CREATING",
+  DELETING: "DELETING",
+  ERROR: "ERROR",
+  READY: "READY",
+  RUNNING: "RUNNING",
+  STARTING: "STARTING",
+  STOPPED: "STOPPED",
+  STOPPING: "STOPPING",
+  UPDATING: "UPDATING"
+};
+var CanaryStateReasonCode = {
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+  CREATE_PENDING: "CREATE_PENDING",
+  DELETE_FAILED: "DELETE_FAILED",
+  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+  INVALID_PERMISSIONS: "INVALID_PERMISSIONS",
+  ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
+  ROLLBACK_FAILED: "ROLLBACK_FAILED",
+  SYNC_DELETE_IN_PROGRESS: "SYNC_DELETE_IN_PROGRESS",
+  UPDATE_COMPLETE: "UPDATE_COMPLETE",
+  UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
+  UPDATE_PENDING: "UPDATE_PENDING"
+};
+var CanaryRunState = {
+  FAILED: "FAILED",
+  PASSED: "PASSED",
+  RUNNING: "RUNNING"
+};
+var CanaryRunStateReasonCode = {
+  CANARY_FAILURE: "CANARY_FAILURE",
+  EXECUTION_FAILURE: "EXECUTION_FAILURE"
+};
+var _RequestEntityTooLargeException = class _RequestEntityTooLargeException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestEntityTooLargeException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestEntityTooLargeException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestEntityTooLargeException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_RequestEntityTooLargeException, "RequestEntityTooLargeException");
+var RequestEntityTooLargeException = _RequestEntityTooLargeException;
+var _InternalFailureException = class _InternalFailureException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalFailureException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalFailureException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalFailureException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalFailureException, "InternalFailureException");
+var InternalFailureException = _InternalFailureException;
+var _NotFoundException = class _NotFoundException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _TooManyRequestsException = class _TooManyRequestsException extends SyntheticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequestsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyRequestsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+
+// src/protocols/Aws_restJson1.ts
+var se_AssociateResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/group/{GroupIdentifier}/associate");
+  b.p("GroupIdentifier", () => input.GroupIdentifier, "{GroupIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ResourceArn: []
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_AssociateResourceCommand");
+var se_CreateCanaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/canary");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ArtifactConfig: (_) => (0, import_smithy_client._json)(_),
+      ArtifactS3Location: [],
+      Code: (_) => se_CanaryCodeInput(_, context),
+      ExecutionRoleArn: [],
+      FailureRetentionPeriodInDays: [],
+      Name: [],
+      RunConfig: (_) => (0, import_smithy_client._json)(_),
+      RuntimeVersion: [],
+      Schedule: (_) => (0, import_smithy_client._json)(_),
+      SuccessRetentionPeriodInDays: [],
+      Tags: (_) => (0, import_smithy_client._json)(_),
+      VpcConfig: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateCanaryCommand");
+var se_CreateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/group");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Name: [],
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateGroupCommand");
+var se_DeleteCanaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/canary/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  const query = (0, import_smithy_client.map)({
+    [_dL]: [() => input.DeleteLambda !== void 0, () => input[_DL].toString()]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteCanaryCommand");
+var se_DeleteGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/group/{GroupIdentifier}");
+  b.p("GroupIdentifier", () => input.GroupIdentifier, "{GroupIdentifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteGroupCommand");
+var se_DescribeCanariesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/canaries");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      Names: (_) => (0, import_smithy_client._json)(_),
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeCanariesCommand");
+var se_DescribeCanariesLastRunCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/canaries/last-run");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      Names: (_) => (0, import_smithy_client._json)(_),
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeCanariesLastRunCommand");
+var se_DescribeRuntimeVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/runtime-versions");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeRuntimeVersionsCommand");
+var se_DisassociateResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/group/{GroupIdentifier}/disassociate");
+  b.p("GroupIdentifier", () => input.GroupIdentifier, "{GroupIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ResourceArn: []
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_DisassociateResourceCommand");
+var se_GetCanaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/canary/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetCanaryCommand");
+var se_GetCanaryRunsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/canary/{Name}/runs");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetCanaryRunsCommand");
+var se_GetGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/group/{GroupIdentifier}");
+  b.p("GroupIdentifier", () => input.GroupIdentifier, "{GroupIdentifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetGroupCommand");
+var se_ListAssociatedGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/resource/{ResourceArn}/groups");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListAssociatedGroupsCommand");
+var se_ListGroupResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/group/{GroupIdentifier}/resources");
+  b.p("GroupIdentifier", () => input.GroupIdentifier, "{GroupIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListGroupResourcesCommand");
+var se_ListGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/groups");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListGroupsCommand");
+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_StartCanaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/canary/{Name}/start");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartCanaryCommand");
+var se_StopCanaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/canary/{Name}/stop");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopCanaryCommand");
+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]: [
+      (0, import_smithy_client.expectNonNull)(input.TagKeys, `TagKeys`) != null,
+      () => (input[_TK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateCanaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/canary/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ArtifactConfig: (_) => (0, import_smithy_client._json)(_),
+      ArtifactS3Location: [],
+      Code: (_) => se_CanaryCodeInput(_, context),
+      ExecutionRoleArn: [],
+      FailureRetentionPeriodInDays: [],
+      RunConfig: (_) => (0, import_smithy_client._json)(_),
+      RuntimeVersion: [],
+      Schedule: (_) => (0, import_smithy_client._json)(_),
+      SuccessRetentionPeriodInDays: [],
+      VisualReference: (_) => (0, import_smithy_client._json)(_),
+      VpcConfig: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UpdateCanaryCommand");
+var de_AssociateResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_AssociateResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_AssociateResourceCommand");
+var de_AssociateResourceCommandError = /* @__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.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.synthetics#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateResourceCommandError");
+var de_CreateCanaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateCanaryCommandError(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, {
+    Canary: (_) => de_Canary(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateCanaryCommand");
+var de_CreateCanaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "RequestEntityTooLargeException":
+    case "com.amazonaws.synthetics#RequestEntityTooLargeException":
+      throw await de_RequestEntityTooLargeExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCanaryCommandError");
+var de_CreateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: (_) => de_Group(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateGroupCommand");
+var de_CreateGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.synthetics#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateGroupCommandError");
+var de_DeleteCanaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteCanaryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteCanaryCommand");
+var de_DeleteCanaryCommandError = /* @__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.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCanaryCommandError");
+var de_DeleteGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteGroupCommand");
+var de_DeleteGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteGroupCommandError");
+var de_DescribeCanariesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeCanariesCommandError(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, {
+    Canaries: (_) => de_Canaries(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeCanariesCommand");
+var de_DescribeCanariesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCanariesCommandError");
+var de_DescribeCanariesLastRunCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeCanariesLastRunCommandError(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, {
+    CanariesLastRun: (_) => de_CanariesLastRun(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeCanariesLastRunCommand");
+var de_DescribeCanariesLastRunCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCanariesLastRunCommandError");
+var de_DescribeRuntimeVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeRuntimeVersionsCommandError(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,
+    RuntimeVersions: (_) => de_RuntimeVersionList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeRuntimeVersionsCommand");
+var de_DescribeRuntimeVersionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRuntimeVersionsCommandError");
+var de_DisassociateResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DisassociateResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DisassociateResourceCommand");
+var de_DisassociateResourceCommandError = /* @__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.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateResourceCommandError");
+var de_GetCanaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCanaryCommandError(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, {
+    Canary: (_) => de_Canary(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetCanaryCommand");
+var de_GetCanaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCanaryCommandError");
+var de_GetCanaryRunsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCanaryRunsCommandError(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, {
+    CanaryRuns: (_) => de_CanaryRuns(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetCanaryRunsCommand");
+var de_GetCanaryRunsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCanaryRunsCommandError");
+var de_GetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: (_) => de_Group(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGroupCommand");
+var de_GetGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGroupCommandError");
+var de_ListAssociatedGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListAssociatedGroupsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Groups: import_smithy_client._json,
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListAssociatedGroupsCommand");
+var de_ListAssociatedGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAssociatedGroupsCommandError");
+var de_ListGroupResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListGroupResourcesCommandError(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,
+    Resources: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListGroupResourcesCommand");
+var de_ListGroupResourcesCommandError = /* @__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.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListGroupResourcesCommandError");
+var de_ListGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListGroupsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Groups: import_smithy_client._json,
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListGroupsCommand");
+var de_ListGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListGroupsCommandError");
+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);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.synthetics#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.synthetics#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.synthetics#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.synthetics#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_StartCanaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartCanaryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StartCanaryCommand");
+var de_StartCanaryCommandError = /* @__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.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartCanaryCommandError");
+var de_StopCanaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopCanaryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StopCanaryCommand");
+var de_StopCanaryCommandError = /* @__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.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopCanaryCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.synthetics#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.synthetics#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.synthetics#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.synthetics#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.synthetics#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.synthetics#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.synthetics#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.synthetics#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateCanaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateCanaryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateCanaryCommand");
+var de_UpdateCanaryCommandError = /* @__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.synthetics#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.synthetics#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "RequestEntityTooLargeException":
+    case "com.amazonaws.synthetics#RequestEntityTooLargeException":
+      throw await de_RequestEntityTooLargeExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.synthetics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.synthetics#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCanaryCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(SyntheticsServiceException);
+var de_BadRequestExceptionRes = /* @__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 BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestExceptionRes");
+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_InternalFailureExceptionRes = /* @__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 InternalFailureException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalFailureExceptionRes");
+var de_InternalServerExceptionRes = /* @__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 InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_NotFoundExceptionRes = /* @__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 NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NotFoundExceptionRes");
+var de_RequestEntityTooLargeExceptionRes = /* @__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 RequestEntityTooLargeException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_RequestEntityTooLargeExceptionRes");
+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_TooManyRequestsExceptionRes = /* @__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 TooManyRequestsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsExceptionRes");
+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 se_CanaryCodeInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Handler: [],
+    S3Bucket: [],
+    S3Key: [],
+    S3Version: [],
+    ZipFile: context.base64Encoder
+  });
+}, "se_CanaryCodeInput");
+var de_Canaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Canary(entry, context);
+  });
+  return retVal;
+}, "de_Canaries");
+var de_CanariesLastRun = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CanaryLastRun(entry, context);
+  });
+  return retVal;
+}, "de_CanariesLastRun");
+var de_Canary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ArtifactConfig: import_smithy_client._json,
+    ArtifactS3Location: import_smithy_client.expectString,
+    Code: import_smithy_client._json,
+    EngineArn: import_smithy_client.expectString,
+    ExecutionRoleArn: import_smithy_client.expectString,
+    FailureRetentionPeriodInDays: import_smithy_client.expectInt32,
+    Id: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    RunConfig: import_smithy_client._json,
+    RuntimeVersion: import_smithy_client.expectString,
+    Schedule: import_smithy_client._json,
+    Status: import_smithy_client._json,
+    SuccessRetentionPeriodInDays: import_smithy_client.expectInt32,
+    Tags: import_smithy_client._json,
+    Timeline: (_) => de_CanaryTimeline(_, context),
+    VisualReference: import_smithy_client._json,
+    VpcConfig: import_smithy_client._json
+  });
+}, "de_Canary");
+var de_CanaryLastRun = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CanaryName: import_smithy_client.expectString,
+    LastRun: (_) => de_CanaryRun(_, context)
+  });
+}, "de_CanaryLastRun");
+var de_CanaryRun = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ArtifactS3Location: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client._json,
+    Timeline: (_) => de_CanaryRunTimeline(_, context)
+  });
+}, "de_CanaryRun");
+var de_CanaryRuns = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CanaryRun(entry, context);
+  });
+  return retVal;
+}, "de_CanaryRuns");
+var de_CanaryRunTimeline = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Completed: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Started: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_CanaryRunTimeline");
+var de_CanaryTimeline = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Created: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LastStarted: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LastStopped: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_CanaryTimeline");
+var de_Group = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Id: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Name: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+}, "de_Group");
+var de_RuntimeVersion = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DeprecationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Description: import_smithy_client.expectString,
+    ReleaseDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VersionName: import_smithy_client.expectString
+  });
+}, "de_RuntimeVersion");
+var de_RuntimeVersionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RuntimeVersion(entry, context);
+  });
+  return retVal;
+}, "de_RuntimeVersionList");
+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 _DL = "DeleteLambda";
+var _TK = "TagKeys";
+var _dL = "deleteLambda";
+var _tK = "tagKeys";
+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/AssociateResourceCommand.ts
+var _AssociateResourceCommand = class _AssociateResourceCommand 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("Synthetics", "AssociateResource", {}).n("SyntheticsClient", "AssociateResourceCommand").f(void 0, void 0).ser(se_AssociateResourceCommand).de(de_AssociateResourceCommand).build() {
+};
+__name(_AssociateResourceCommand, "AssociateResourceCommand");
+var AssociateResourceCommand = _AssociateResourceCommand;
+
+// src/commands/CreateCanaryCommand.ts
+
+
+
+
+var _CreateCanaryCommand = class _CreateCanaryCommand 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("Synthetics", "CreateCanary", {}).n("SyntheticsClient", "CreateCanaryCommand").f(void 0, void 0).ser(se_CreateCanaryCommand).de(de_CreateCanaryCommand).build() {
+};
+__name(_CreateCanaryCommand, "CreateCanaryCommand");
+var CreateCanaryCommand = _CreateCanaryCommand;
+
+// src/commands/CreateGroupCommand.ts
+
+
+
+
+var _CreateGroupCommand = class _CreateGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Synthetics", "CreateGroup", {}).n("SyntheticsClient", "CreateGroupCommand").f(void 0, void 0).ser(se_CreateGroupCommand).de(de_CreateGroupCommand).build() {
+};
+__name(_CreateGroupCommand, "CreateGroupCommand");
+var CreateGroupCommand = _CreateGroupCommand;
+
+// src/commands/DeleteCanaryCommand.ts
+
+
+
+
+var _DeleteCanaryCommand = class _DeleteCanaryCommand 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("Synthetics", "DeleteCanary", {}).n("SyntheticsClient", "DeleteCanaryCommand").f(void 0, void 0).ser(se_DeleteCanaryCommand).de(de_DeleteCanaryCommand).build() {
+};
+__name(_DeleteCanaryCommand, "DeleteCanaryCommand");
+var DeleteCanaryCommand = _DeleteCanaryCommand;
+
+// src/commands/DeleteGroupCommand.ts
+
+
+
+
+var _DeleteGroupCommand = class _DeleteGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Synthetics", "DeleteGroup", {}).n("SyntheticsClient", "DeleteGroupCommand").f(void 0, void 0).ser(se_DeleteGroupCommand).de(de_DeleteGroupCommand).build() {
+};
+__name(_DeleteGroupCommand, "DeleteGroupCommand");
+var DeleteGroupCommand = _DeleteGroupCommand;
+
+// src/commands/DescribeCanariesCommand.ts
+
+
+
+
+var _DescribeCanariesCommand = class _DescribeCanariesCommand 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("Synthetics", "DescribeCanaries", {}).n("SyntheticsClient", "DescribeCanariesCommand").f(void 0, void 0).ser(se_DescribeCanariesCommand).de(de_DescribeCanariesCommand).build() {
+};
+__name(_DescribeCanariesCommand, "DescribeCanariesCommand");
+var DescribeCanariesCommand = _DescribeCanariesCommand;
+
+// src/commands/DescribeCanariesLastRunCommand.ts
+
+
+
+
+var _DescribeCanariesLastRunCommand = class _DescribeCanariesLastRunCommand 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("Synthetics", "DescribeCanariesLastRun", {}).n("SyntheticsClient", "DescribeCanariesLastRunCommand").f(void 0, void 0).ser(se_DescribeCanariesLastRunCommand).de(de_DescribeCanariesLastRunCommand).build() {
+};
+__name(_DescribeCanariesLastRunCommand, "DescribeCanariesLastRunCommand");
+var DescribeCanariesLastRunCommand = _DescribeCanariesLastRunCommand;
+
+// src/commands/DescribeRuntimeVersionsCommand.ts
+
+
+
+
+var _DescribeRuntimeVersionsCommand = class _DescribeRuntimeVersionsCommand 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("Synthetics", "DescribeRuntimeVersions", {}).n("SyntheticsClient", "DescribeRuntimeVersionsCommand").f(void 0, void 0).ser(se_DescribeRuntimeVersionsCommand).de(de_DescribeRuntimeVersionsCommand).build() {
+};
+__name(_DescribeRuntimeVersionsCommand, "DescribeRuntimeVersionsCommand");
+var DescribeRuntimeVersionsCommand = _DescribeRuntimeVersionsCommand;
+
+// src/commands/DisassociateResourceCommand.ts
+
+
+
+
+var _DisassociateResourceCommand = class _DisassociateResourceCommand 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("Synthetics", "DisassociateResource", {}).n("SyntheticsClient", "DisassociateResourceCommand").f(void 0, void 0).ser(se_DisassociateResourceCommand).de(de_DisassociateResourceCommand).build() {
+};
+__name(_DisassociateResourceCommand, "DisassociateResourceCommand");
+var DisassociateResourceCommand = _DisassociateResourceCommand;
+
+// src/commands/GetCanaryCommand.ts
+
+
+
+
+var _GetCanaryCommand = class _GetCanaryCommand 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("Synthetics", "GetCanary", {}).n("SyntheticsClient", "GetCanaryCommand").f(void 0, void 0).ser(se_GetCanaryCommand).de(de_GetCanaryCommand).build() {
+};
+__name(_GetCanaryCommand, "GetCanaryCommand");
+var GetCanaryCommand = _GetCanaryCommand;
+
+// src/commands/GetCanaryRunsCommand.ts
+
+
+
+
+var _GetCanaryRunsCommand = class _GetCanaryRunsCommand 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("Synthetics", "GetCanaryRuns", {}).n("SyntheticsClient", "GetCanaryRunsCommand").f(void 0, void 0).ser(se_GetCanaryRunsCommand).de(de_GetCanaryRunsCommand).build() {
+};
+__name(_GetCanaryRunsCommand, "GetCanaryRunsCommand");
+var GetCanaryRunsCommand = _GetCanaryRunsCommand;
+
+// src/commands/GetGroupCommand.ts
+
+
+
+
+var _GetGroupCommand = class _GetGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Synthetics", "GetGroup", {}).n("SyntheticsClient", "GetGroupCommand").f(void 0, void 0).ser(se_GetGroupCommand).de(de_GetGroupCommand).build() {
+};
+__name(_GetGroupCommand, "GetGroupCommand");
+var GetGroupCommand = _GetGroupCommand;
+
+// src/commands/ListAssociatedGroupsCommand.ts
+
+
+
+
+var _ListAssociatedGroupsCommand = class _ListAssociatedGroupsCommand 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("Synthetics", "ListAssociatedGroups", {}).n("SyntheticsClient", "ListAssociatedGroupsCommand").f(void 0, void 0).ser(se_ListAssociatedGroupsCommand).de(de_ListAssociatedGroupsCommand).build() {
+};
+__name(_ListAssociatedGroupsCommand, "ListAssociatedGroupsCommand");
+var ListAssociatedGroupsCommand = _ListAssociatedGroupsCommand;
+
+// src/commands/ListGroupResourcesCommand.ts
+
+
+
+
+var _ListGroupResourcesCommand = class _ListGroupResourcesCommand 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("Synthetics", "ListGroupResources", {}).n("SyntheticsClient", "ListGroupResourcesCommand").f(void 0, void 0).ser(se_ListGroupResourcesCommand).de(de_ListGroupResourcesCommand).build() {
+};
+__name(_ListGroupResourcesCommand, "ListGroupResourcesCommand");
+var ListGroupResourcesCommand = _ListGroupResourcesCommand;
+
+// src/commands/ListGroupsCommand.ts
+
+
+
+
+var _ListGroupsCommand = class _ListGroupsCommand 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("Synthetics", "ListGroups", {}).n("SyntheticsClient", "ListGroupsCommand").f(void 0, void 0).ser(se_ListGroupsCommand).de(de_ListGroupsCommand).build() {
+};
+__name(_ListGroupsCommand, "ListGroupsCommand");
+var ListGroupsCommand = _ListGroupsCommand;
+
+// 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("Synthetics", "ListTagsForResource", {}).n("SyntheticsClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/StartCanaryCommand.ts
+
+
+
+
+var _StartCanaryCommand = class _StartCanaryCommand 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("Synthetics", "StartCanary", {}).n("SyntheticsClient", "StartCanaryCommand").f(void 0, void 0).ser(se_StartCanaryCommand).de(de_StartCanaryCommand).build() {
+};
+__name(_StartCanaryCommand, "StartCanaryCommand");
+var StartCanaryCommand = _StartCanaryCommand;
+
+// src/commands/StopCanaryCommand.ts
+
+
+
+
+var _StopCanaryCommand = class _StopCanaryCommand 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("Synthetics", "StopCanary", {}).n("SyntheticsClient", "StopCanaryCommand").f(void 0, void 0).ser(se_StopCanaryCommand).de(de_StopCanaryCommand).build() {
+};
+__name(_StopCanaryCommand, "StopCanaryCommand");
+var StopCanaryCommand = _StopCanaryCommand;
+
+// 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("Synthetics", "TagResource", {}).n("SyntheticsClient", "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("Synthetics", "UntagResource", {}).n("SyntheticsClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateCanaryCommand.ts
+
+
+
+
+var _UpdateCanaryCommand = class _UpdateCanaryCommand 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("Synthetics", "UpdateCanary", {}).n("SyntheticsClient", "UpdateCanaryCommand").f(void 0, void 0).ser(se_UpdateCanaryCommand).de(de_UpdateCanaryCommand).build() {
+};
+__name(_UpdateCanaryCommand, "UpdateCanaryCommand");
+var UpdateCanaryCommand = _UpdateCanaryCommand;
+
+// src/Synthetics.ts
+var commands = {
+  AssociateResourceCommand,
+  CreateCanaryCommand,
+  CreateGroupCommand,
+  DeleteCanaryCommand,
+  DeleteGroupCommand,
+  DescribeCanariesCommand,
+  DescribeCanariesLastRunCommand,
+  DescribeRuntimeVersionsCommand,
+  DisassociateResourceCommand,
+  GetCanaryCommand,
+  GetCanaryRunsCommand,
+  GetGroupCommand,
+  ListAssociatedGroupsCommand,
+  ListGroupResourcesCommand,
+  ListGroupsCommand,
+  ListTagsForResourceCommand,
+  StartCanaryCommand,
+  StopCanaryCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateCanaryCommand
+};
+var _Synthetics = class _Synthetics extends SyntheticsClient {
+};
+__name(_Synthetics, "Synthetics");
+var Synthetics = _Synthetics;
+(0, import_smithy_client.createAggregatedClient)(commands, Synthetics);
+
+// src/pagination/DescribeCanariesLastRunPaginator.ts
+
+var paginateDescribeCanariesLastRun = (0, import_core.createPaginator)(SyntheticsClient, DescribeCanariesLastRunCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeCanariesPaginator.ts
+
+var paginateDescribeCanaries = (0, import_core.createPaginator)(SyntheticsClient, DescribeCanariesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeRuntimeVersionsPaginator.ts
+
+var paginateDescribeRuntimeVersions = (0, import_core.createPaginator)(SyntheticsClient, DescribeRuntimeVersionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/GetCanaryRunsPaginator.ts
+
+var paginateGetCanaryRuns = (0, import_core.createPaginator)(SyntheticsClient, GetCanaryRunsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListAssociatedGroupsPaginator.ts
+
+var paginateListAssociatedGroups = (0, import_core.createPaginator)(SyntheticsClient, ListAssociatedGroupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListGroupResourcesPaginator.ts
+
+var paginateListGroupResources = (0, import_core.createPaginator)(SyntheticsClient, ListGroupResourcesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListGroupsPaginator.ts
+
+var paginateListGroups = (0, import_core.createPaginator)(SyntheticsClient, ListGroupsCommand, "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 = {
+  AssociateResourceCommand,
+  BadRequestException,
+  CanaryRunState,
+  CanaryRunStateReasonCode,
+  CanaryState,
+  CanaryStateReasonCode,
+  ConflictException,
+  CreateCanaryCommand,
+  CreateGroupCommand,
+  DeleteCanaryCommand,
+  DeleteGroupCommand,
+  DescribeCanariesCommand,
+  DescribeCanariesLastRunCommand,
+  DescribeRuntimeVersionsCommand,
+  DisassociateResourceCommand,
+  EncryptionMode,
+  GetCanaryCommand,
+  GetCanaryRunsCommand,
+  GetGroupCommand,
+  InternalFailureException,
+  InternalServerException,
+  ListAssociatedGroupsCommand,
+  ListGroupResourcesCommand,
+  ListGroupsCommand,
+  ListTagsForResourceCommand,
+  NotFoundException,
+  RequestEntityTooLargeException,
+  ResourceNotFoundException,
+  ServiceQuotaExceededException,
+  StartCanaryCommand,
+  StopCanaryCommand,
+  Synthetics,
+  SyntheticsClient,
+  SyntheticsServiceException,
+  TagResourceCommand,
+  TooManyRequestsException,
+  UntagResourceCommand,
+  UpdateCanaryCommand,
+  ValidationException,
+  __Client,
+  paginateDescribeCanaries,
+  paginateDescribeCanariesLastRun,
+  paginateDescribeRuntimeVersions,
+  paginateGetCanaryRuns,
+  paginateListAssociatedGroups,
+  paginateListGroupResources,
+  paginateListGroups
+});