@aws-sdk/client-synthetics 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class SyntheticsClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class SyntheticsClient extends smithyClient.Client {
     }
 }
 
-class SyntheticsServiceException extends smithyClient.ServiceException {
+let SyntheticsServiceException$1 = class SyntheticsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SyntheticsServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends SyntheticsServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends SyntheticsServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -130,12 +130,12 @@ class AccessDeniedException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const EncryptionMode = {
     SSE_KMS: "SSE_KMS",
     SSE_S3: "SSE_S3",
 };
-class ConflictException extends SyntheticsServiceException {
+let ConflictException$1 = class ConflictException extends SyntheticsServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -148,8 +148,8 @@ class ConflictException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.Message = opts.Message;
     }
-}
-class InternalServerException extends SyntheticsServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends SyntheticsServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     Message;
@@ -162,8 +162,8 @@ class InternalServerException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceNotFoundException extends SyntheticsServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends SyntheticsServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -176,8 +176,8 @@ class ResourceNotFoundException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class ServiceQuotaExceededException extends SyntheticsServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends SyntheticsServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -190,8 +190,8 @@ class ServiceQuotaExceededException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationException extends SyntheticsServiceException {
+};
+let ValidationException$1 = class ValidationException extends SyntheticsServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -204,8 +204,8 @@ class ValidationException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.Message = opts.Message;
     }
-}
-class BadRequestException extends SyntheticsServiceException {
+};
+let BadRequestException$1 = class BadRequestException extends SyntheticsServiceException$1 {
     name = "BadRequestException";
     $fault = "client";
     Message;
@@ -218,7 +218,7 @@ class BadRequestException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, BadRequestException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const BrowserType = {
     CHROME: "CHROME",
     FIREFOX: "FIREFOX",
@@ -272,7 +272,7 @@ const CanaryRunTestResult = {
 const ResourceToTag = {
     LAMBDA_FUNCTION: "lambda-function",
 };
-class RequestEntityTooLargeException extends SyntheticsServiceException {
+let RequestEntityTooLargeException$1 = class RequestEntityTooLargeException extends SyntheticsServiceException$1 {
     name = "RequestEntityTooLargeException";
     $fault = "client";
     Message;
@@ -285,12 +285,12 @@ class RequestEntityTooLargeException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, RequestEntityTooLargeException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const RunType = {
     CANARY_RUN: "CANARY_RUN",
     DRY_RUN: "DRY_RUN",
 };
-class InternalFailureException extends SyntheticsServiceException {
+let InternalFailureException$1 = class InternalFailureException extends SyntheticsServiceException$1 {
     name = "InternalFailureException";
     $fault = "server";
     Message;
@@ -303,8 +303,8 @@ class InternalFailureException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, InternalFailureException.prototype);
         this.Message = opts.Message;
     }
-}
-class NotFoundException extends SyntheticsServiceException {
+};
+let NotFoundException$1 = class NotFoundException extends SyntheticsServiceException$1 {
     name = "NotFoundException";
     $fault = "client";
     Message;
@@ -317,8 +317,8 @@ class NotFoundException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, NotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class TooManyRequestsException extends SyntheticsServiceException {
+};
+let TooManyRequestsException$1 = class TooManyRequestsException extends SyntheticsServiceException$1 {
     name = "TooManyRequestsException";
     $fault = "client";
     Message;
@@ -331,952 +331,930 @@ class TooManyRequestsException extends SyntheticsServiceException {
         Object.setPrototypeOf(this, TooManyRequestsException.prototype);
         this.Message = opts.Message;
     }
-}
-
-const se_AssociateResourceCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        ResourceArn: [],
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_CreateCanaryCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/canary");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ArtifactConfig: (_) => smithyClient._json(_),
-        ArtifactS3Location: [],
-        BrowserConfigs: (_) => smithyClient._json(_),
-        Code: (_) => se_CanaryCodeInput(_, context),
-        ExecutionRoleArn: [],
-        FailureRetentionPeriodInDays: [],
-        Name: [],
-        ProvisionedResourceCleanup: [],
-        ResourcesToReplicateTags: (_) => smithyClient._json(_),
-        RunConfig: (_) => smithyClient._json(_),
-        RuntimeVersion: [],
-        Schedule: (_) => smithyClient._json(_),
-        SuccessRetentionPeriodInDays: [],
-        Tags: (_) => smithyClient._json(_),
-        VpcConfig: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateGroupCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/group");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Name: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteCanaryCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/canary/{Name}");
-    b.p("Name", () => input.Name, "{Name}", false);
-    const query = smithyClient.map({
-        [_dL]: [() => input.DeleteLambda !== void 0, () => input[_DL].toString()],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_DeleteGroupCommand = async (input, context) => {
-    const b = 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();
-};
-const se_DescribeCanariesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/canaries");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        Names: (_) => smithyClient._json(_),
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeCanariesLastRunCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/canaries/last-run");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        BrowserType: [],
-        MaxResults: [],
-        Names: (_) => smithyClient._json(_),
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeRuntimeVersionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/runtime-versions");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DisassociateResourceCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        ResourceArn: [],
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_GetCanaryCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/canary/{Name}");
-    b.p("Name", () => input.Name, "{Name}", false);
-    const query = smithyClient.map({
-        [_dRI]: [, input[_DRI]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetCanaryRunsCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        DryRunId: [],
-        MaxResults: [],
-        NextToken: [],
-        RunType: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetGroupCommand = async (input, context) => {
-    const b = 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();
-};
-const se_ListAssociatedGroupsCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListGroupResourcesCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListGroupsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/groups");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = 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();
-};
-const se_StartCanaryCommand = async (input, context) => {
-    const b = 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();
-};
-const se_StartCanaryDryRunCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/canary/{Name}/dry-run/start");
-    b.p("Name", () => input.Name, "{Name}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ArtifactConfig: (_) => smithyClient._json(_),
-        ArtifactS3Location: [],
-        BrowserConfigs: (_) => smithyClient._json(_),
-        Code: (_) => se_CanaryCodeInput(_, context),
-        ExecutionRoleArn: [],
-        FailureRetentionPeriodInDays: [],
-        ProvisionedResourceCleanup: [],
-        RunConfig: (_) => smithyClient._json(_),
-        RuntimeVersion: [],
-        SuccessRetentionPeriodInDays: [],
-        VisualReference: (_) => smithyClient._json(_),
-        VisualReferences: (_) => smithyClient._json(_),
-        VpcConfig: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopCanaryCommand = async (input, context) => {
-    const b = 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();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateCanaryCommand = async (input, context) => {
-    const b = 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(smithyClient.take(input, {
-        ArtifactConfig: (_) => smithyClient._json(_),
-        ArtifactS3Location: [],
-        BrowserConfigs: (_) => smithyClient._json(_),
-        Code: (_) => se_CanaryCodeInput(_, context),
-        DryRunId: [],
-        ExecutionRoleArn: [],
-        FailureRetentionPeriodInDays: [],
-        ProvisionedResourceCleanup: [],
-        RunConfig: (_) => smithyClient._json(_),
-        RuntimeVersion: [],
-        Schedule: (_) => smithyClient._json(_),
-        SuccessRetentionPeriodInDays: [],
-        VisualReference: (_) => smithyClient._json(_),
-        VisualReferences: (_) => smithyClient._json(_),
-        VpcConfig: (_) => smithyClient._json(_),
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const de_AssociateResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CreateCanaryCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Canary: (_) => de_Canary(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateGroupCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Group: (_) => de_Group(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteCanaryCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteGroupCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DescribeCanariesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Canaries: (_) => de_Canaries(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeCanariesLastRunCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        CanariesLastRun: (_) => de_CanariesLastRun(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeRuntimeVersionsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        RuntimeVersions: (_) => de_RuntimeVersionList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DisassociateResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_GetCanaryCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Canary: (_) => de_Canary(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetCanaryRunsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        CanaryRuns: (_) => de_CanaryRuns(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
 };
-const de_GetGroupCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Group: (_) => de_Group(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListAssociatedGroupsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Groups: smithyClient._json,
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListGroupResourcesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        Resources: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListGroupsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Groups: smithyClient._json,
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartCanaryCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_StartCanaryDryRunCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        DryRunConfig: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StopCanaryCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateCanaryCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.synthetics#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.synthetics#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.synthetics#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.synthetics#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.synthetics#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "RequestEntityTooLargeException":
-        case "com.amazonaws.synthetics#RequestEntityTooLargeException":
-            throw await de_RequestEntityTooLargeExceptionRes(parsedOutput);
-        case "BadRequestException":
-        case "com.amazonaws.synthetics#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput);
-        case "InternalFailureException":
-        case "com.amazonaws.synthetics#InternalFailureException":
-            throw await de_InternalFailureExceptionRes(parsedOutput);
-        case "NotFoundException":
-        case "com.amazonaws.synthetics#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput);
-        case "TooManyRequestsException":
-        case "com.amazonaws.synthetics#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput);
-        case "AccessDeniedException":
-        case "com.amazonaws.synthetics#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(SyntheticsServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_BadRequestExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new BadRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalFailureException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new NotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_RequestEntityTooLargeExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new RequestEntityTooLargeException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new TooManyRequestsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_CanaryCodeInput = (input, context) => {
-    return smithyClient.take(input, {
-        BlueprintTypes: smithyClient._json,
-        Dependencies: smithyClient._json,
-        Handler: [],
-        S3Bucket: [],
-        S3Key: [],
-        S3Version: [],
-        ZipFile: context.base64Encoder,
-    });
-};
-const de_Canaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Canary(entry);
-    });
-    return retVal;
-};
-const de_CanariesLastRun = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CanaryLastRun(entry);
-    });
-    return retVal;
-};
-const de_Canary = (output, context) => {
-    return smithyClient.take(output, {
-        ArtifactConfig: smithyClient._json,
-        ArtifactS3Location: smithyClient.expectString,
-        BrowserConfigs: smithyClient._json,
-        Code: smithyClient._json,
-        DryRunConfig: smithyClient._json,
-        EngineArn: smithyClient.expectString,
-        EngineConfigs: smithyClient._json,
-        ExecutionRoleArn: smithyClient.expectString,
-        FailureRetentionPeriodInDays: smithyClient.expectInt32,
-        Id: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        ProvisionedResourceCleanup: smithyClient.expectString,
-        RunConfig: smithyClient._json,
-        RuntimeVersion: smithyClient.expectString,
-        Schedule: smithyClient._json,
-        Status: smithyClient._json,
-        SuccessRetentionPeriodInDays: smithyClient.expectInt32,
-        Tags: smithyClient._json,
-        Timeline: (_) => de_CanaryTimeline(_),
-        VisualReference: smithyClient._json,
-        VisualReferences: smithyClient._json,
-        VpcConfig: smithyClient._json,
-    });
-};
-const de_CanaryLastRun = (output, context) => {
-    return smithyClient.take(output, {
-        CanaryName: smithyClient.expectString,
-        LastRun: (_) => de_CanaryRun(_),
-    });
-};
-const de_CanaryRun = (output, context) => {
-    return smithyClient.take(output, {
-        ArtifactS3Location: smithyClient.expectString,
-        BrowserType: smithyClient.expectString,
-        DryRunConfig: smithyClient._json,
-        Id: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        RetryAttempt: smithyClient.expectInt32,
-        ScheduledRunId: smithyClient.expectString,
-        Status: smithyClient._json,
-        Timeline: (_) => de_CanaryRunTimeline(_),
-    });
-};
-const de_CanaryRuns = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CanaryRun(entry);
-    });
-    return retVal;
-};
-const de_CanaryRunTimeline = (output, context) => {
-    return smithyClient.take(output, {
-        Completed: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MetricTimestampForRunAndRetries: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Started: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_CanaryTimeline = (output, context) => {
-    return smithyClient.take(output, {
-        Created: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LastModified: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LastStarted: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LastStopped: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_Group = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Id: smithyClient.expectString,
-        LastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Name: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-};
-const de_RuntimeVersion = (output, context) => {
-    return smithyClient.take(output, {
-        DeprecationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Description: smithyClient.expectString,
-        ReleaseDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        VersionName: smithyClient.expectString,
-    });
-};
-const de_RuntimeVersionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_RuntimeVersion(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (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"],
-});
+
+const _A = "Arn";
+const _AC = "ArtifactConfig";
+const _ACI = "ArtifactConfigInput";
+const _ACO = "ArtifactConfigOutput";
+const _ADE = "AccessDeniedException";
+const _AR = "AssociateResource";
+const _ARR = "AssociateResourceRequest";
+const _ARRs = "AssociateResourceResponse";
+const _ASL = "ArtifactS3Location";
+const _AT = "ActiveTracing";
+const _BC = "BrowserConfig";
+const _BCRI = "BaseCanaryRunId";
+const _BCr = "BrowserConfigs";
+const _BRE = "BadRequestException";
+const _BS = "BaseScreenshot";
+const _BSa = "BaseScreenshots";
+const _BT = "BrowserType";
+const _BTl = "BlueprintTypes";
+const _C = "Canary";
+const _CC = "CreateCanary";
+const _CCI = "CanaryCodeInput";
+const _CCO = "CanaryCodeOutput";
+const _CCR = "CreateCanaryRequest";
+const _CCRr = "CreateCanaryResponse";
+const _CDRCO = "CanaryDryRunConfigOutput";
+const _CE = "ConflictException";
+const _CG = "CreateGroup";
+const _CGR = "CreateGroupRequest";
+const _CGRr = "CreateGroupResponse";
+const _CLR = "CanaryLastRun";
+const _CLRa = "CanariesLastRun";
+const _CN = "CanaryName";
+const _CR = "CanaryRun";
+const _CRCI = "CanaryRunConfigInput";
+const _CRCO = "CanaryRunConfigOutput";
+const _CRS = "CanaryRunStatus";
+const _CRT = "CanaryRunTimeline";
+const _CRa = "CanaryRuns";
+const _CS = "CanaryStatus";
+const _CSI = "CanaryScheduleInput";
+const _CSO = "CanaryScheduleOutput";
+const _CT = "CanaryTimeline";
+const _CTr = "CreatedTime";
+const _Ca = "Canaries";
+const _Co = "Code";
+const _Com = "Completed";
+const _Cr = "Created";
+const _D = "Dependencies";
+const _DC = "DeleteCanary";
+const _DCLR = "DescribeCanariesLastRun";
+const _DCLRR = "DescribeCanariesLastRunRequest";
+const _DCLRRe = "DescribeCanariesLastRunResponse";
+const _DCR = "DeleteCanaryRequest";
+const _DCRe = "DeleteCanaryResponse";
+const _DCRes = "DescribeCanariesRequest";
+const _DCResc = "DescribeCanariesResponse";
+const _DCe = "DescribeCanaries";
+const _DD = "DeprecationDate";
+const _DG = "DeleteGroup";
+const _DGR = "DeleteGroupRequest";
+const _DGRe = "DeleteGroupResponse";
+const _DIS = "DurationInSeconds";
 const _DL = "DeleteLambda";
+const _DR = "DisassociateResource";
+const _DRC = "DryRunConfig";
+const _DRCO = "DryRunConfigOutput";
 const _DRI = "DryRunId";
+const _DRR = "DisassociateResourceRequest";
+const _DRRi = "DisassociateResourceResponse";
+const _DRV = "DescribeRuntimeVersions";
+const _DRVR = "DescribeRuntimeVersionsRequest";
+const _DRVRe = "DescribeRuntimeVersionsResponse";
+const _De = "Dependency";
+const _Des = "Description";
+const _E = "Expression";
+const _EA = "EngineArn";
+const _EC = "EngineConfigs";
+const _ECn = "EngineConfig";
+const _EM = "EncryptionMode";
+const _ERA = "ExecutionRoleArn";
+const _ES = "EphemeralStorage";
+const _EV = "EnvironmentVariables";
+const _FRPID = "FailureRetentionPeriodInDays";
+const _G = "Group";
+const _GC = "GetCanary";
+const _GCR = "GetCanaryRequest";
+const _GCRR = "GetCanaryRunsRequest";
+const _GCRRe = "GetCanaryRunsResponse";
+const _GCRe = "GetCanaryResponse";
+const _GCRet = "GetCanaryRuns";
+const _GG = "GetGroup";
+const _GGR = "GetGroupRequest";
+const _GGRe = "GetGroupResponse";
+const _GI = "GroupIdentifier";
+const _GS = "GroupSummary";
+const _GSL = "GroupSummaryList";
+const _Gr = "Groups";
+const _H = "Handler";
+const _I = "Id";
+const _IAFDS = "Ipv6AllowedForDualStack";
+const _IC = "IgnoreCoordinates";
+const _IFE = "InternalFailureException";
+const _ISE = "InternalServerException";
+const _KKA = "KmsKeyArn";
+const _LAG = "ListAssociatedGroups";
+const _LAGR = "ListAssociatedGroupsRequest";
+const _LAGRi = "ListAssociatedGroupsResponse";
+const _LDRES = "LastDryRunExecutionStatus";
+const _LG = "ListGroups";
+const _LGR = "ListGroupsRequest";
+const _LGRR = "ListGroupResourcesRequest";
+const _LGRRi = "ListGroupResourcesResponse";
+const _LGRi = "ListGroupsResponse";
+const _LGRis = "ListGroupResources";
+const _LM = "LastModified";
+const _LMT = "LastModifiedTime";
+const _LR = "LastRun";
+const _LS = "LastStarted";
+const _LSa = "LastStopped";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _M = "Message";
+const _MIMB = "MemoryInMB";
+const _MR = "MaxResults";
+const _MRa = "MaxRetries";
+const _MTFRAR = "MetricTimestampForRunAndRetries";
+const _N = "Name";
+const _NFE = "NotFoundException";
+const _NT = "NextToken";
+const _Na = "Names";
+const _PRC = "ProvisionedResourceCleanup";
+const _R = "Reference";
+const _RA = "ResourceArn";
+const _RAe = "RetryAttempt";
+const _RC = "RunConfig";
+const _RCI = "RetryConfigInput";
+const _RCO = "RetryConfigOutput";
+const _RCe = "RetryConfig";
+const _RD = "ReleaseDate";
+const _RETLE = "RequestEntityTooLargeException";
+const _RNFE = "ResourceNotFoundException";
+const _RT = "RunType";
+const _RTRT = "ResourcesToReplicateTags";
+const _RV = "RuntimeVersion";
+const _RVL = "RuntimeVersionList";
+const _RVu = "RuntimeVersions";
+const _Re = "Resources";
+const _S = "Schedule";
+const _SB = "S3Bucket";
+const _SC = "StartCanary";
+const _SCDR = "StartCanaryDryRun";
+const _SCDRR = "StartCanaryDryRunRequest";
+const _SCDRRt = "StartCanaryDryRunResponse";
+const _SCR = "StartCanaryRequest";
+const _SCRt = "StartCanaryResponse";
+const _SCRto = "StopCanaryRequest";
+const _SCRtop = "StopCanaryResponse";
+const _SCt = "StopCanary";
+const _SE = "S3Encryption";
+const _SEC = "S3EncryptionConfig";
+const _SGI = "SecurityGroupIds";
+const _SI = "SubnetIds";
+const _SK = "S3Key";
+const _SLA = "SourceLocationArn";
+const _SN = "ScreenshotName";
+const _SQEE = "ServiceQuotaExceededException";
+const _SR = "StateReason";
+const _SRC = "StateReasonCode";
+const _SRI = "ScheduledRunId";
+const _SRPID = "SuccessRetentionPeriodInDays";
+const _SV = "S3Version";
+const _St = "Status";
+const _Sta = "State";
+const _Star = "Started";
+const _T = "Timeline";
+const _TIS = "TimeoutInSeconds";
 const _TK = "TagKeys";
+const _TMRE = "TooManyRequestsException";
+const _TR = "TestResult";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TRa = "TagResource";
+const _Ta = "Tags";
+const _Ty = "Type";
+const _UC = "UpdateCanary";
+const _UCR = "UpdateCanaryRequest";
+const _UCRp = "UpdateCanaryResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _VC = "VpcConfig";
+const _VCI = "VpcConfigInput";
+const _VCO = "VpcConfigOutput";
+const _VE = "ValidationException";
+const _VI = "VpcId";
+const _VN = "VersionName";
+const _VR = "VisualReference";
+const _VRI = "VisualReferenceInput";
+const _VRO = "VisualReferenceOutput";
+const _VROi = "VisualReferencesOutput";
+const _VRi = "VisualReferences";
+const _ZF = "ZipFile";
+const _c = "client";
 const _dL = "deleteLambda";
 const _dRI = "dryRunId";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.synthetics";
 const _tK = "tagKeys";
+const n0 = "com.amazonaws.synthetics";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ArtifactConfigInput = [3, n0, _ACI, 0, [_SE], [() => S3EncryptionConfig]];
+var ArtifactConfigOutput = [3, n0, _ACO, 0, [_SE], [() => S3EncryptionConfig]];
+var AssociateResourceRequest = [3, n0, _ARR, 0, [_GI, _RA], [[0, 1], 0]];
+var AssociateResourceResponse = [3, n0, _ARRs, 0, [], []];
+var BadRequestException = [
+    -3,
+    n0,
+    _BRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(BadRequestException, BadRequestException$1);
+var BaseScreenshot = [3, n0, _BS, 0, [_SN, _IC], [0, 64 | 0]];
+var BrowserConfig = [3, n0, _BC, 0, [_BT], [0]];
+var Canary = [
+    3,
+    n0,
+    _C,
+    0,
+    [
+        _I,
+        _N,
+        _Co,
+        _ERA,
+        _S,
+        _RC,
+        _SRPID,
+        _FRPID,
+        _St,
+        _T,
+        _ASL,
+        _EA,
+        _RV,
+        _VC,
+        _VR,
+        _PRC,
+        _BCr,
+        _EC,
+        _VRi,
+        _Ta,
+        _AC,
+        _DRC,
+    ],
+    [
+        0,
+        0,
+        () => CanaryCodeOutput,
+        0,
+        () => CanaryScheduleOutput,
+        () => CanaryRunConfigOutput,
+        1,
+        1,
+        () => CanaryStatus,
+        () => CanaryTimeline,
+        0,
+        0,
+        0,
+        () => VpcConfigOutput,
+        () => VisualReferenceOutput,
+        0,
+        () => BrowserConfigs,
+        () => EngineConfigs,
+        () => VisualReferencesOutput,
+        128 | 0,
+        () => ArtifactConfigOutput,
+        () => DryRunConfigOutput,
+    ],
+];
+var CanaryCodeInput = [
+    3,
+    n0,
+    _CCI,
+    0,
+    [_SB, _SK, _SV, _ZF, _H, _BTl, _D],
+    [0, 0, 0, 21, 0, 64 | 0, () => Dependencies],
+];
+var CanaryCodeOutput = [
+    3,
+    n0,
+    _CCO,
+    0,
+    [_SLA, _H, _BTl, _D],
+    [0, 0, 64 | 0, () => Dependencies],
+];
+var CanaryDryRunConfigOutput = [3, n0, _CDRCO, 0, [_DRI], [0]];
+var CanaryLastRun = [3, n0, _CLR, 0, [_CN, _LR], [0, () => CanaryRun]];
+var CanaryRun = [
+    3,
+    n0,
+    _CR,
+    0,
+    [_I, _SRI, _RAe, _N, _St, _T, _ASL, _DRC, _BT],
+    [0, 0, 1, 0, () => CanaryRunStatus, () => CanaryRunTimeline, 0, () => CanaryDryRunConfigOutput, 0],
+];
+var CanaryRunConfigInput = [
+    3,
+    n0,
+    _CRCI,
+    0,
+    [_TIS, _MIMB, _AT, _EV, _ES],
+    [1, 1, 2, 128 | 0, 1],
+];
+var CanaryRunConfigOutput = [3, n0, _CRCO, 0, [_TIS, _MIMB, _AT, _ES], [1, 1, 2, 1]];
+var CanaryRunStatus = [3, n0, _CRS, 0, [_Sta, _SR, _SRC, _TR], [0, 0, 0, 0]];
+var CanaryRunTimeline = [3, n0, _CRT, 0, [_Star, _Com, _MTFRAR], [4, 4, 4]];
+var CanaryScheduleInput = [
+    3,
+    n0,
+    _CSI,
+    0,
+    [_E, _DIS, _RCe],
+    [0, 1, () => RetryConfigInput],
+];
+var CanaryScheduleOutput = [
+    3,
+    n0,
+    _CSO,
+    0,
+    [_E, _DIS, _RCe],
+    [0, 1, () => RetryConfigOutput],
+];
+var CanaryStatus = [3, n0, _CS, 0, [_Sta, _SR, _SRC], [0, 0, 0]];
+var CanaryTimeline = [3, n0, _CT, 0, [_Cr, _LM, _LS, _LSa], [4, 4, 4, 4]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateCanaryRequest = [
+    3,
+    n0,
+    _CCR,
+    0,
+    [_N, _Co, _ASL, _ERA, _S, _RC, _SRPID, _FRPID, _RV, _VC, _RTRT, _PRC, _BCr, _Ta, _AC],
+    [
+        0,
+        () => CanaryCodeInput,
+        0,
+        0,
+        () => CanaryScheduleInput,
+        () => CanaryRunConfigInput,
+        1,
+        1,
+        0,
+        () => VpcConfigInput,
+        64 | 0,
+        0,
+        () => BrowserConfigs,
+        128 | 0,
+        () => ArtifactConfigInput,
+    ],
+];
+var CreateCanaryResponse = [3, n0, _CCRr, 0, [_C], [() => Canary]];
+var CreateGroupRequest = [3, n0, _CGR, 0, [_N, _Ta], [0, 128 | 0]];
+var CreateGroupResponse = [3, n0, _CGRr, 0, [_G], [() => Group]];
+var DeleteCanaryRequest = [
+    3,
+    n0,
+    _DCR,
+    0,
+    [_N, _DL],
+    [
+        [0, 1],
+        [
+            2,
+            {
+                [_hQ]: _dL,
+            },
+        ],
+    ],
+];
+var DeleteCanaryResponse = [3, n0, _DCRe, 0, [], []];
+var DeleteGroupRequest = [3, n0, _DGR, 0, [_GI], [[0, 1]]];
+var DeleteGroupResponse = [3, n0, _DGRe, 0, [], []];
+var Dependency = [3, n0, _De, 0, [_Ty, _R], [0, 0]];
+var DescribeCanariesLastRunRequest = [
+    3,
+    n0,
+    _DCLRR,
+    0,
+    [_NT, _MR, _Na, _BT],
+    [0, 1, 64 | 0, 0],
+];
+var DescribeCanariesLastRunResponse = [
+    3,
+    n0,
+    _DCLRRe,
+    0,
+    [_CLRa, _NT],
+    [() => CanariesLastRun, 0],
+];
+var DescribeCanariesRequest = [3, n0, _DCRes, 0, [_NT, _MR, _Na], [0, 1, 64 | 0]];
+var DescribeCanariesResponse = [3, n0, _DCResc, 0, [_Ca, _NT], [() => Canaries, 0]];
+var DescribeRuntimeVersionsRequest = [3, n0, _DRVR, 0, [_NT, _MR], [0, 1]];
+var DescribeRuntimeVersionsResponse = [
+    3,
+    n0,
+    _DRVRe,
+    0,
+    [_RVu, _NT],
+    [() => RuntimeVersionList, 0],
+];
+var DisassociateResourceRequest = [3, n0, _DRR, 0, [_GI, _RA], [[0, 1], 0]];
+var DisassociateResourceResponse = [3, n0, _DRRi, 0, [], []];
+var DryRunConfigOutput = [3, n0, _DRCO, 0, [_DRI, _LDRES], [0, 0]];
+var EngineConfig = [3, n0, _ECn, 0, [_EA, _BT], [0, 0]];
+var GetCanaryRequest = [
+    3,
+    n0,
+    _GCR,
+    0,
+    [_N, _DRI],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _dRI,
+            },
+        ],
+    ],
+];
+var GetCanaryResponse = [3, n0, _GCRe, 0, [_C], [() => Canary]];
+var GetCanaryRunsRequest = [
+    3,
+    n0,
+    _GCRR,
+    0,
+    [_N, _NT, _MR, _DRI, _RT],
+    [[0, 1], 0, 1, 0, 0],
+];
+var GetCanaryRunsResponse = [3, n0, _GCRRe, 0, [_CRa, _NT], [() => CanaryRuns, 0]];
+var GetGroupRequest = [3, n0, _GGR, 0, [_GI], [[0, 1]]];
+var GetGroupResponse = [3, n0, _GGRe, 0, [_G], [() => Group]];
+var Group = [3, n0, _G, 0, [_I, _N, _A, _Ta, _CTr, _LMT], [0, 0, 0, 128 | 0, 4, 4]];
+var GroupSummary = [3, n0, _GS, 0, [_I, _N, _A], [0, 0, 0]];
+var InternalFailureException = [
+    -3,
+    n0,
+    _IFE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalFailureException, InternalFailureException$1);
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListAssociatedGroupsRequest = [3, n0, _LAGR, 0, [_NT, _MR, _RA], [0, 1, [0, 1]]];
+var ListAssociatedGroupsResponse = [
+    3,
+    n0,
+    _LAGRi,
+    0,
+    [_Gr, _NT],
+    [() => GroupSummaryList, 0],
+];
+var ListGroupResourcesRequest = [3, n0, _LGRR, 0, [_NT, _MR, _GI], [0, 1, [0, 1]]];
+var ListGroupResourcesResponse = [3, n0, _LGRRi, 0, [_Re, _NT], [64 | 0, 0]];
+var ListGroupsRequest = [3, n0, _LGR, 0, [_NT, _MR], [0, 1]];
+var ListGroupsResponse = [3, n0, _LGRi, 0, [_Gr, _NT], [() => GroupSummaryList, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_Ta], [128 | 0]];
+var NotFoundException = [
+    -3,
+    n0,
+    _NFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NotFoundException, NotFoundException$1);
+var RequestEntityTooLargeException = [
+    -3,
+    n0,
+    _RETLE,
+    {
+        [_e]: _c,
+        [_hE]: 413,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RequestEntityTooLargeException, RequestEntityTooLargeException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var RetryConfigInput = [3, n0, _RCI, 0, [_MRa], [1]];
+var RetryConfigOutput = [3, n0, _RCO, 0, [_MRa], [1]];
+var RuntimeVersion = [3, n0, _RV, 0, [_VN, _Des, _RD, _DD], [0, 0, 4, 4]];
+var S3EncryptionConfig = [3, n0, _SEC, 0, [_EM, _KKA], [0, 0]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var StartCanaryDryRunRequest = [
+    3,
+    n0,
+    _SCDRR,
+    0,
+    [_N, _Co, _RV, _RC, _VC, _ERA, _SRPID, _FRPID, _VR, _ASL, _AC, _PRC, _BCr, _VRi],
+    [
+        [0, 1],
+        () => CanaryCodeInput,
+        0,
+        () => CanaryRunConfigInput,
+        () => VpcConfigInput,
+        0,
+        1,
+        1,
+        () => VisualReferenceInput,
+        0,
+        () => ArtifactConfigInput,
+        0,
+        () => BrowserConfigs,
+        () => VisualReferences,
+    ],
+];
+var StartCanaryDryRunResponse = [3, n0, _SCDRRt, 0, [_DRC], [() => DryRunConfigOutput]];
+var StartCanaryRequest = [3, n0, _SCR, 0, [_N], [[0, 1]]];
+var StartCanaryResponse = [3, n0, _SCRt, 0, [], []];
+var StopCanaryRequest = [3, n0, _SCRto, 0, [_N], [[0, 1]]];
+var StopCanaryResponse = [3, n0, _SCRtop, 0, [], []];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RA, _Ta], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TooManyRequestsException = [
+    -3,
+    n0,
+    _TMRE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyRequestsException, TooManyRequestsException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_RA, _TK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateCanaryRequest = [
+    3,
+    n0,
+    _UCR,
+    0,
+    [_N, _Co, _ERA, _RV, _S, _RC, _SRPID, _FRPID, _VC, _VR, _ASL, _AC, _PRC, _DRI, _VRi, _BCr],
+    [
+        [0, 1],
+        () => CanaryCodeInput,
+        0,
+        0,
+        () => CanaryScheduleInput,
+        () => CanaryRunConfigInput,
+        1,
+        1,
+        () => VpcConfigInput,
+        () => VisualReferenceInput,
+        0,
+        () => ArtifactConfigInput,
+        0,
+        0,
+        () => VisualReferences,
+        () => BrowserConfigs,
+    ],
+];
+var UpdateCanaryResponse = [3, n0, _UCRp, 0, [], []];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var VisualReferenceInput = [
+    3,
+    n0,
+    _VRI,
+    0,
+    [_BSa, _BCRI, _BT],
+    [() => BaseScreenshots, 0, 0],
+];
+var VisualReferenceOutput = [
+    3,
+    n0,
+    _VRO,
+    0,
+    [_BSa, _BCRI, _BT],
+    [() => BaseScreenshots, 0, 0],
+];
+var VpcConfigInput = [3, n0, _VCI, 0, [_SI, _SGI, _IAFDS], [64 | 0, 64 | 0, 2]];
+var VpcConfigOutput = [3, n0, _VCO, 0, [_VI, _SI, _SGI, _IAFDS], [0, 64 | 0, 64 | 0, 2]];
+var SyntheticsServiceException = [-3, _sm, "SyntheticsServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(SyntheticsServiceException, SyntheticsServiceException$1);
+var BaseScreenshots = [1, n0, _BSa, 0, () => BaseScreenshot];
+var BrowserConfigs = [1, n0, _BCr, 0, () => BrowserConfig];
+var Canaries = [1, n0, _Ca, 0, () => Canary];
+var CanariesLastRun = [1, n0, _CLRa, 0, () => CanaryLastRun];
+var CanaryRuns = [1, n0, _CRa, 0, () => CanaryRun];
+var Dependencies = [1, n0, _D, 0, () => Dependency];
+var EngineConfigs = [1, n0, _EC, 0, () => EngineConfig];
+var GroupSummaryList = [1, n0, _GSL, 0, () => GroupSummary];
+var RuntimeVersionList = [1, n0, _RVL, 0, () => RuntimeVersion];
+var VisualReferences = [1, n0, _VRi, 0, () => VisualReferenceInput];
+var VisualReferencesOutput = [1, n0, _VROi, 0, () => VisualReferenceOutput];
+var AssociateResource = [
+    9,
+    n0,
+    _AR,
+    {
+        [_h]: ["PATCH", "/group/{GroupIdentifier}/associate", 200],
+    },
+    () => AssociateResourceRequest,
+    () => AssociateResourceResponse,
+];
+var CreateCanary = [
+    9,
+    n0,
+    _CC,
+    {
+        [_h]: ["POST", "/canary", 200],
+    },
+    () => CreateCanaryRequest,
+    () => CreateCanaryResponse,
+];
+var CreateGroup = [
+    9,
+    n0,
+    _CG,
+    {
+        [_h]: ["POST", "/group", 200],
+    },
+    () => CreateGroupRequest,
+    () => CreateGroupResponse,
+];
+var DeleteCanary = [
+    9,
+    n0,
+    _DC,
+    {
+        [_h]: ["DELETE", "/canary/{Name}", 200],
+    },
+    () => DeleteCanaryRequest,
+    () => DeleteCanaryResponse,
+];
+var DeleteGroup = [
+    9,
+    n0,
+    _DG,
+    {
+        [_h]: ["DELETE", "/group/{GroupIdentifier}", 200],
+    },
+    () => DeleteGroupRequest,
+    () => DeleteGroupResponse,
+];
+var DescribeCanaries = [
+    9,
+    n0,
+    _DCe,
+    {
+        [_h]: ["POST", "/canaries", 200],
+    },
+    () => DescribeCanariesRequest,
+    () => DescribeCanariesResponse,
+];
+var DescribeCanariesLastRun = [
+    9,
+    n0,
+    _DCLR,
+    {
+        [_h]: ["POST", "/canaries/last-run", 200],
+    },
+    () => DescribeCanariesLastRunRequest,
+    () => DescribeCanariesLastRunResponse,
+];
+var DescribeRuntimeVersions = [
+    9,
+    n0,
+    _DRV,
+    {
+        [_h]: ["POST", "/runtime-versions", 200],
+    },
+    () => DescribeRuntimeVersionsRequest,
+    () => DescribeRuntimeVersionsResponse,
+];
+var DisassociateResource = [
+    9,
+    n0,
+    _DR,
+    {
+        [_h]: ["PATCH", "/group/{GroupIdentifier}/disassociate", 200],
+    },
+    () => DisassociateResourceRequest,
+    () => DisassociateResourceResponse,
+];
+var GetCanary = [
+    9,
+    n0,
+    _GC,
+    {
+        [_h]: ["GET", "/canary/{Name}", 200],
+    },
+    () => GetCanaryRequest,
+    () => GetCanaryResponse,
+];
+var GetCanaryRuns = [
+    9,
+    n0,
+    _GCRet,
+    {
+        [_h]: ["POST", "/canary/{Name}/runs", 200],
+    },
+    () => GetCanaryRunsRequest,
+    () => GetCanaryRunsResponse,
+];
+var GetGroup = [
+    9,
+    n0,
+    _GG,
+    {
+        [_h]: ["GET", "/group/{GroupIdentifier}", 200],
+    },
+    () => GetGroupRequest,
+    () => GetGroupResponse,
+];
+var ListAssociatedGroups = [
+    9,
+    n0,
+    _LAG,
+    {
+        [_h]: ["POST", "/resource/{ResourceArn}/groups", 200],
+    },
+    () => ListAssociatedGroupsRequest,
+    () => ListAssociatedGroupsResponse,
+];
+var ListGroupResources = [
+    9,
+    n0,
+    _LGRis,
+    {
+        [_h]: ["POST", "/group/{GroupIdentifier}/resources", 200],
+    },
+    () => ListGroupResourcesRequest,
+    () => ListGroupResourcesResponse,
+];
+var ListGroups = [
+    9,
+    n0,
+    _LG,
+    {
+        [_h]: ["POST", "/groups", 200],
+    },
+    () => ListGroupsRequest,
+    () => ListGroupsResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{ResourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var StartCanary = [
+    9,
+    n0,
+    _SC,
+    {
+        [_h]: ["POST", "/canary/{Name}/start", 200],
+    },
+    () => StartCanaryRequest,
+    () => StartCanaryResponse,
+];
+var StartCanaryDryRun = [
+    9,
+    n0,
+    _SCDR,
+    {
+        [_h]: ["POST", "/canary/{Name}/dry-run/start", 200],
+    },
+    () => StartCanaryDryRunRequest,
+    () => StartCanaryDryRunResponse,
+];
+var StopCanary = [
+    9,
+    n0,
+    _SCt,
+    {
+        [_h]: ["POST", "/canary/{Name}/stop", 200],
+    },
+    () => StopCanaryRequest,
+    () => StopCanaryResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TRa,
+    {
+        [_h]: ["POST", "/tags/{ResourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{ResourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateCanary = [
+    9,
+    n0,
+    _UC,
+    {
+        [_h]: ["PATCH", "/canary/{Name}", 200],
+    },
+    () => UpdateCanaryRequest,
+    () => UpdateCanaryResponse,
+];
 
 class AssociateResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "AssociateResource", {})
     .n("SyntheticsClient", "AssociateResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_AssociateResourceCommand)
-    .de(de_AssociateResourceCommand)
+    .sc(AssociateResource)
     .build() {
 }
 
@@ -1284,16 +1262,11 @@ class CreateCanaryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "CreateCanary", {})
     .n("SyntheticsClient", "CreateCanaryCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateCanaryCommand)
-    .de(de_CreateCanaryCommand)
+    .sc(CreateCanary)
     .build() {
 }
 
@@ -1301,16 +1274,11 @@ class CreateGroupCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "CreateGroup", {})
     .n("SyntheticsClient", "CreateGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateGroupCommand)
-    .de(de_CreateGroupCommand)
+    .sc(CreateGroup)
     .build() {
 }
 
@@ -1318,16 +1286,11 @@ class DeleteCanaryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "DeleteCanary", {})
     .n("SyntheticsClient", "DeleteCanaryCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteCanaryCommand)
-    .de(de_DeleteCanaryCommand)
+    .sc(DeleteCanary)
     .build() {
 }
 
@@ -1335,16 +1298,11 @@ class DeleteGroupCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "DeleteGroup", {})
     .n("SyntheticsClient", "DeleteGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteGroupCommand)
-    .de(de_DeleteGroupCommand)
+    .sc(DeleteGroup)
     .build() {
 }
 
@@ -1352,16 +1310,11 @@ class DescribeCanariesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "DescribeCanaries", {})
     .n("SyntheticsClient", "DescribeCanariesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeCanariesCommand)
-    .de(de_DescribeCanariesCommand)
+    .sc(DescribeCanaries)
     .build() {
 }
 
@@ -1369,16 +1322,11 @@ class DescribeCanariesLastRunCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "DescribeCanariesLastRun", {})
     .n("SyntheticsClient", "DescribeCanariesLastRunCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeCanariesLastRunCommand)
-    .de(de_DescribeCanariesLastRunCommand)
+    .sc(DescribeCanariesLastRun)
     .build() {
 }
 
@@ -1386,16 +1334,11 @@ class DescribeRuntimeVersionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "DescribeRuntimeVersions", {})
     .n("SyntheticsClient", "DescribeRuntimeVersionsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeRuntimeVersionsCommand)
-    .de(de_DescribeRuntimeVersionsCommand)
+    .sc(DescribeRuntimeVersions)
     .build() {
 }
 
@@ -1403,16 +1346,11 @@ class DisassociateResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "DisassociateResource", {})
     .n("SyntheticsClient", "DisassociateResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_DisassociateResourceCommand)
-    .de(de_DisassociateResourceCommand)
+    .sc(DisassociateResource)
     .build() {
 }
 
@@ -1420,16 +1358,11 @@ class GetCanaryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "GetCanary", {})
     .n("SyntheticsClient", "GetCanaryCommand")
-    .f(void 0, void 0)
-    .ser(se_GetCanaryCommand)
-    .de(de_GetCanaryCommand)
+    .sc(GetCanary)
     .build() {
 }
 
@@ -1437,16 +1370,11 @@ class GetCanaryRunsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "GetCanaryRuns", {})
     .n("SyntheticsClient", "GetCanaryRunsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetCanaryRunsCommand)
-    .de(de_GetCanaryRunsCommand)
+    .sc(GetCanaryRuns)
     .build() {
 }
 
@@ -1454,16 +1382,11 @@ class GetGroupCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "GetGroup", {})
     .n("SyntheticsClient", "GetGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_GetGroupCommand)
-    .de(de_GetGroupCommand)
+    .sc(GetGroup)
     .build() {
 }
 
@@ -1471,16 +1394,11 @@ class ListAssociatedGroupsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "ListAssociatedGroups", {})
     .n("SyntheticsClient", "ListAssociatedGroupsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListAssociatedGroupsCommand)
-    .de(de_ListAssociatedGroupsCommand)
+    .sc(ListAssociatedGroups)
     .build() {
 }
 
@@ -1488,16 +1406,11 @@ class ListGroupResourcesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "ListGroupResources", {})
     .n("SyntheticsClient", "ListGroupResourcesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListGroupResourcesCommand)
-    .de(de_ListGroupResourcesCommand)
+    .sc(ListGroupResources)
     .build() {
 }
 
@@ -1505,16 +1418,11 @@ class ListGroupsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "ListGroups", {})
     .n("SyntheticsClient", "ListGroupsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListGroupsCommand)
-    .de(de_ListGroupsCommand)
+    .sc(ListGroups)
     .build() {
 }
 
@@ -1522,16 +1430,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "ListTagsForResource", {})
     .n("SyntheticsClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1539,16 +1442,11 @@ class StartCanaryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "StartCanary", {})
     .n("SyntheticsClient", "StartCanaryCommand")
-    .f(void 0, void 0)
-    .ser(se_StartCanaryCommand)
-    .de(de_StartCanaryCommand)
+    .sc(StartCanary)
     .build() {
 }
 
@@ -1556,16 +1454,11 @@ class StartCanaryDryRunCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "StartCanaryDryRun", {})
     .n("SyntheticsClient", "StartCanaryDryRunCommand")
-    .f(void 0, void 0)
-    .ser(se_StartCanaryDryRunCommand)
-    .de(de_StartCanaryDryRunCommand)
+    .sc(StartCanaryDryRun)
     .build() {
 }
 
@@ -1573,16 +1466,11 @@ class StopCanaryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "StopCanary", {})
     .n("SyntheticsClient", "StopCanaryCommand")
-    .f(void 0, void 0)
-    .ser(se_StopCanaryCommand)
-    .de(de_StopCanaryCommand)
+    .sc(StopCanary)
     .build() {
 }
 
@@ -1590,16 +1478,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "TagResource", {})
     .n("SyntheticsClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1607,16 +1490,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "UntagResource", {})
     .n("SyntheticsClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1624,16 +1502,11 @@ class UpdateCanaryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Synthetics", "UpdateCanary", {})
     .n("SyntheticsClient", "UpdateCanaryCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateCanaryCommand)
-    .de(de_UpdateCanaryCommand)
+    .sc(UpdateCanary)
     .build() {
 }
 
@@ -1687,16 +1560,16 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AssociateResourceCommand = AssociateResourceCommand;
-exports.BadRequestException = BadRequestException;
+exports.BadRequestException = BadRequestException$1;
 exports.BrowserType = BrowserType;
 exports.CanaryRunState = CanaryRunState;
 exports.CanaryRunStateReasonCode = CanaryRunStateReasonCode;
 exports.CanaryRunTestResult = CanaryRunTestResult;
 exports.CanaryState = CanaryState;
 exports.CanaryStateReasonCode = CanaryStateReasonCode;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateCanaryCommand = CreateCanaryCommand;
 exports.CreateGroupCommand = CreateGroupCommand;
 exports.DeleteCanaryCommand = DeleteCanaryCommand;
@@ -1710,30 +1583,30 @@ exports.EncryptionMode = EncryptionMode;
 exports.GetCanaryCommand = GetCanaryCommand;
 exports.GetCanaryRunsCommand = GetCanaryRunsCommand;
 exports.GetGroupCommand = GetGroupCommand;
-exports.InternalFailureException = InternalFailureException;
-exports.InternalServerException = InternalServerException;
+exports.InternalFailureException = InternalFailureException$1;
+exports.InternalServerException = InternalServerException$1;
 exports.ListAssociatedGroupsCommand = ListAssociatedGroupsCommand;
 exports.ListGroupResourcesCommand = ListGroupResourcesCommand;
 exports.ListGroupsCommand = ListGroupsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
-exports.NotFoundException = NotFoundException;
+exports.NotFoundException = NotFoundException$1;
 exports.ProvisionedResourceCleanupSetting = ProvisionedResourceCleanupSetting;
-exports.RequestEntityTooLargeException = RequestEntityTooLargeException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.RequestEntityTooLargeException = RequestEntityTooLargeException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResourceToTag = ResourceToTag;
 exports.RunType = RunType;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.StartCanaryCommand = StartCanaryCommand;
 exports.StartCanaryDryRunCommand = StartCanaryDryRunCommand;
 exports.StopCanaryCommand = StopCanaryCommand;
 exports.Synthetics = Synthetics;
 exports.SyntheticsClient = SyntheticsClient;
-exports.SyntheticsServiceException = SyntheticsServiceException;
+exports.SyntheticsServiceException = SyntheticsServiceException$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.TooManyRequestsException = TooManyRequestsException;
+exports.TooManyRequestsException = TooManyRequestsException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateCanaryCommand = UpdateCanaryCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateDescribeCanaries = paginateDescribeCanaries;
 exports.paginateDescribeCanariesLastRun = paginateDescribeCanariesLastRun;
 exports.paginateDescribeRuntimeVersions = paginateDescribeRuntimeVersions;