@aws-sdk/client-fis 3.183.0 → 3.185.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,1185 +1,1572 @@
+import { __assign, __awaiter, __generator, __read } from "tslib";
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map as __map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { FisServiceException as __BaseException } from "../models/FisServiceException";
 import { ConflictException, ResourceNotFoundException, ServiceQuotaExceededException, ValidationException, } from "../models/models_0";
-export const serializeAws_restJson1CreateExperimentTemplateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {
-        "content-type": "application/json",
-    };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experimentTemplates";
-    let body;
-    body = JSON.stringify({
-        ...(input.actions != null && {
-            actions: serializeAws_restJson1CreateExperimentTemplateActionInputMap(input.actions, context),
-        }),
-        clientToken: input.clientToken ?? generateIdempotencyToken(),
-        ...(input.description != null && { description: input.description }),
-        ...(input.logConfiguration != null && {
-            logConfiguration: serializeAws_restJson1CreateExperimentTemplateLogConfigurationInput(input.logConfiguration, context),
-        }),
-        ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.stopConditions != null && {
-            stopConditions: serializeAws_restJson1CreateExperimentTemplateStopConditionInputList(input.stopConditions, context),
-        }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
-        ...(input.targets != null && {
-            targets: serializeAws_restJson1CreateExperimentTemplateTargetInputMap(input.targets, context),
-        }),
-    });
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1DeleteExperimentTemplateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experimentTemplates/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1GetActionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actions/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1GetExperimentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experiments/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1GetExperimentTemplateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experimentTemplates/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1GetTargetResourceTypeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetResourceTypes/{resourceType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceType", () => input.resourceType, "{resourceType}", false);
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1ListActionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actions";
-    const query = map({
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        nextToken: [, input.nextToken],
-    });
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
-};
-export const serializeAws_restJson1ListExperimentsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experiments";
-    const query = map({
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        nextToken: [, input.nextToken],
-    });
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
-};
-export const serializeAws_restJson1ListExperimentTemplatesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experimentTemplates";
-    const query = map({
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        nextToken: [, input.nextToken],
-    });
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
-};
-export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1ListTargetResourceTypesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetResourceTypes";
-    const query = map({
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        nextToken: [, input.nextToken],
-    });
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
-};
-export const serializeAws_restJson1StartExperimentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {
-        "content-type": "application/json",
-    };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experiments";
-    let body;
-    body = JSON.stringify({
-        clientToken: input.clientToken ?? generateIdempotencyToken(),
-        ...(input.experimentTemplateId != null && { experimentTemplateId: input.experimentTemplateId }),
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
-    });
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1StopExperimentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experiments/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {
-        "content-type": "application/json",
-    };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify({
-        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
-    });
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = map({
-        tagKeys: [() => input.tagKeys !== void 0, () => (input.tagKeys || []).map((_entry) => _entry)],
-    });
-    let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
-};
-export const serializeAws_restJson1UpdateExperimentTemplateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {
-        "content-type": "application/json",
-    };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/experimentTemplates/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
-    let body;
-    body = JSON.stringify({
-        ...(input.actions != null && {
-            actions: serializeAws_restJson1UpdateExperimentTemplateActionInputMap(input.actions, context),
-        }),
-        ...(input.description != null && { description: input.description }),
-        ...(input.logConfiguration != null && {
-            logConfiguration: serializeAws_restJson1UpdateExperimentTemplateLogConfigurationInput(input.logConfiguration, context),
-        }),
-        ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.stopConditions != null && {
-            stopConditions: serializeAws_restJson1UpdateExperimentTemplateStopConditionInputList(input.stopConditions, context),
-        }),
-        ...(input.targets != null && {
-            targets: serializeAws_restJson1UpdateExperimentTemplateTargetInputMap(input.targets, context),
-        }),
-    });
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
-export const deserializeAws_restJson1CreateExperimentTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateExperimentTemplateCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+export var serializeAws_restJson1CreateExperimentTemplateCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _d.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experimentTemplates";
+                body = JSON.stringify(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.actions != null && {
+                    actions: serializeAws_restJson1CreateExperimentTemplateActionInputMap(input.actions, context),
+                })), { clientToken: (_c = input.clientToken) !== null && _c !== void 0 ? _c : generateIdempotencyToken() }), (input.description != null && { description: input.description })), (input.logConfiguration != null && {
+                    logConfiguration: serializeAws_restJson1CreateExperimentTemplateLogConfigurationInput(input.logConfiguration, context),
+                })), (input.roleArn != null && { roleArn: input.roleArn })), (input.stopConditions != null && {
+                    stopConditions: serializeAws_restJson1CreateExperimentTemplateStopConditionInputList(input.stopConditions, context),
+                })), (input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) })), (input.targets != null && {
+                    targets: serializeAws_restJson1CreateExperimentTemplateTargetInputMap(input.targets, context),
+                })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experimentTemplate != null) {
-        contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1CreateExperimentTemplateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.fis#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.fis#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1DeleteExperimentTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteExperimentTemplateCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1DeleteExperimentTemplateCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experimentTemplates/{id}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "id", function () { return input.id; }, "{id}", false);
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "DELETE",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experimentTemplate != null) {
-        contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1DeleteExperimentTemplateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1GetActionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetActionCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1GetActionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/actions/{id}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "id", function () { return input.id; }, "{id}", false);
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.action != null) {
-        contents.action = deserializeAws_restJson1Action(data.action, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1GetActionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1GetExperimentCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetExperimentCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1GetExperimentCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experiments/{id}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "id", function () { return input.id; }, "{id}", false);
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experiment != null) {
-        contents.experiment = deserializeAws_restJson1Experiment(data.experiment, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1GetExperimentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1GetExperimentTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetExperimentTemplateCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1GetExperimentTemplateCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experimentTemplates/{id}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "id", function () { return input.id; }, "{id}", false);
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experimentTemplate != null) {
-        contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1GetExperimentTemplateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1GetTargetResourceTypeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetTargetResourceTypeCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1GetTargetResourceTypeCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/targetResourceTypes/{resourceType}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "resourceType", function () { return input.resourceType; }, "{resourceType}", false);
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.targetResourceType != null) {
-        contents.targetResourceType = deserializeAws_restJson1TargetResourceType(data.targetResourceType, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1GetTargetResourceTypeCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1ListActionsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListActionsCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1ListActionsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, query, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/actions";
+                query = map({
+                    maxResults: [function () { return input.maxResults !== void 0; }, function () { return input.maxResults.toString(); }],
+                    nextToken: [, input.nextToken],
+                });
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        query: query,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.actions != null) {
-        contents.actions = deserializeAws_restJson1ActionSummaryList(data.actions, context);
-    }
-    if (data.nextToken != null) {
-        contents.nextToken = __expectString(data.nextToken);
-    }
-    return contents;
-};
-const deserializeAws_restJson1ListActionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1ListExperimentsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListExperimentsCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1ListExperimentsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, query, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experiments";
+                query = map({
+                    maxResults: [function () { return input.maxResults !== void 0; }, function () { return input.maxResults.toString(); }],
+                    nextToken: [, input.nextToken],
+                });
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        query: query,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experiments != null) {
-        contents.experiments = deserializeAws_restJson1ExperimentSummaryList(data.experiments, context);
-    }
-    if (data.nextToken != null) {
-        contents.nextToken = __expectString(data.nextToken);
-    }
-    return contents;
-};
-const deserializeAws_restJson1ListExperimentsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1ListExperimentTemplatesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListExperimentTemplatesCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1ListExperimentTemplatesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, query, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experimentTemplates";
+                query = map({
+                    maxResults: [function () { return input.maxResults !== void 0; }, function () { return input.maxResults.toString(); }],
+                    nextToken: [, input.nextToken],
+                });
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        query: query,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experimentTemplates != null) {
-        contents.experimentTemplates = deserializeAws_restJson1ExperimentTemplateSummaryList(data.experimentTemplates, context);
-    }
-    if (data.nextToken != null) {
-        contents.nextToken = __expectString(data.nextToken);
-    }
-    return contents;
-};
-const deserializeAws_restJson1ListExperimentTemplatesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1ListTagsForResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/tags/{resourceArn}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", function () { return input.resourceArn; }, "{resourceArn}", false);
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.tags != null) {
-        contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_restJson1ListTargetResourceTypesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTargetResourceTypesCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1ListTargetResourceTypesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, query, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/targetResourceTypes";
+                query = map({
+                    maxResults: [function () { return input.maxResults !== void 0; }, function () { return input.maxResults.toString(); }],
+                    nextToken: [, input.nextToken],
+                });
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "GET",
+                        headers: headers,
+                        path: resolvedPath,
+                        query: query,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.nextToken != null) {
-        contents.nextToken = __expectString(data.nextToken);
-    }
-    if (data.targetResourceTypes != null) {
-        contents.targetResourceTypes = deserializeAws_restJson1TargetResourceTypeSummaryList(data.targetResourceTypes, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1ListTargetResourceTypesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1StartExperimentCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartExperimentCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1StartExperimentCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _d.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experiments";
+                body = JSON.stringify(__assign(__assign({ clientToken: (_c = input.clientToken) !== null && _c !== void 0 ? _c : generateIdempotencyToken() }, (input.experimentTemplateId != null && { experimentTemplateId: input.experimentTemplateId })), (input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experiment != null) {
-        contents.experiment = deserializeAws_restJson1Experiment(data.experiment, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1StartExperimentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConflictException":
-        case "com.amazonaws.fis#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.fis#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1StopExperimentCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StopExperimentCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1StopExperimentCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experiments/{id}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "id", function () { return input.id; }, "{id}", false);
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "DELETE",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experiment != null) {
-        contents.experiment = deserializeAws_restJson1Experiment(data.experiment, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1StopExperimentCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1TagResourceCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1TagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/tags/{resourceArn}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", function () { return input.resourceArn; }, "{resourceArn}", false);
+                body = JSON.stringify(__assign({}, (input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    await collectBody(output.body, context);
-    return contents;
-};
-const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UntagResourceCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1UntagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, query, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {};
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/tags/{resourceArn}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", function () { return input.resourceArn; }, "{resourceArn}", false);
+                query = map({
+                    tagKeys: [function () { return input.tagKeys !== void 0; }, function () { return (input.tagKeys || []).map(function (_entry) { return _entry; }); }],
+                });
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "DELETE",
+                        headers: headers,
+                        path: resolvedPath,
+                        query: query,
+                        body: body,
+                    })];
+        }
     });
-    await collectBody(output.body, context);
-    return contents;
-};
-const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    const parsedBody = parsedOutput.body;
-    throwDefaultError({
-        output,
-        parsedBody,
-        exceptionCtor: __BaseException,
-        errorCode,
-    });
-};
-export const deserializeAws_restJson1UpdateExperimentTemplateCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UpdateExperimentTemplateCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
+}); };
+export var serializeAws_restJson1UpdateExperimentTemplateCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/experimentTemplates/{id}";
+                resolvedPath = __resolvedPath(resolvedPath, input, "id", function () { return input.id; }, "{id}", false);
+                body = JSON.stringify(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.actions != null && {
+                    actions: serializeAws_restJson1UpdateExperimentTemplateActionInputMap(input.actions, context),
+                })), (input.description != null && { description: input.description })), (input.logConfiguration != null && {
+                    logConfiguration: serializeAws_restJson1UpdateExperimentTemplateLogConfigurationInput(input.logConfiguration, context),
+                })), (input.roleArn != null && { roleArn: input.roleArn })), (input.stopConditions != null && {
+                    stopConditions: serializeAws_restJson1UpdateExperimentTemplateStopConditionInputList(input.stopConditions, context),
+                })), (input.targets != null && {
+                    targets: serializeAws_restJson1UpdateExperimentTemplateTargetInputMap(input.targets, context),
+                })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "PATCH",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
     });
-    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.experimentTemplate != null) {
-        contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
-    }
-    return contents;
-};
-const deserializeAws_restJson1UpdateExperimentTemplateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ResourceNotFoundException":
-        case "com.amazonaws.fis#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.fis#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.fis#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-const map = __map;
-const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.message = __expectString(data.message);
-    }
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
+}); };
+export var deserializeAws_restJson1CreateExperimentTemplateCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1CreateExperimentTemplateCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experimentTemplate != null) {
+                    contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
+                }
+                return [2, contents];
+        }
     });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.message = __expectString(data.message);
-    }
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
+}); };
+var deserializeAws_restJson1CreateExperimentTemplateCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ConflictException": return [3, 2];
+                    case "com.amazonaws.fis#ConflictException": return [3, 2];
+                    case "ResourceNotFoundException": return [3, 4];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 4];
+                    case "ServiceQuotaExceededException": return [3, 6];
+                    case "com.amazonaws.fis#ServiceQuotaExceededException": return [3, 6];
+                    case "ValidationException": return [3, 8];
+                    case "com.amazonaws.fis#ValidationException": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 11;
+            case 11: return [2];
+        }
     });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.message = __expectString(data.message);
-    }
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
+}); };
+export var deserializeAws_restJson1DeleteExperimentTemplateCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1DeleteExperimentTemplateCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experimentTemplate != null) {
+                    contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
+                }
+                return [2, contents];
+        }
     });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
-    const contents = map({});
-    const data = parsedOutput.body;
-    if (data.message != null) {
-        contents.message = __expectString(data.message);
-    }
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
+}); };
+var deserializeAws_restJson1DeleteExperimentTemplateCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ResourceNotFoundException": return [3, 2];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 2];
+                    case "ValidationException": return [3, 4];
+                    case "com.amazonaws.fis#ValidationException": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
     });
-    return __decorateServiceException(exception, parsedOutput.body);
-};
-const serializeAws_restJson1CreateExperimentTemplateActionInput = (input, context) => {
-    return {
-        ...(input.actionId != null && { actionId: input.actionId }),
-        ...(input.description != null && { description: input.description }),
-        ...(input.parameters != null && {
-            parameters: serializeAws_restJson1ExperimentTemplateActionParameterMap(input.parameters, context),
-        }),
-        ...(input.startAfter != null && {
-            startAfter: serializeAws_restJson1ExperimentTemplateActionStartAfterList(input.startAfter, context),
-        }),
-        ...(input.targets != null && {
-            targets: serializeAws_restJson1ExperimentTemplateActionTargetMap(input.targets, context),
-        }),
-    };
-};
-const serializeAws_restJson1CreateExperimentTemplateActionInputMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+}); };
+export var deserializeAws_restJson1GetActionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1GetActionCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.action != null) {
+                    contents.action = deserializeAws_restJson1Action(data.action, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1GetActionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ResourceNotFoundException": return [3, 2];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 2];
+                    case "ValidationException": return [3, 4];
+                    case "com.amazonaws.fis#ValidationException": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1GetExperimentCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1GetExperimentCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experiment != null) {
+                    contents.experiment = deserializeAws_restJson1Experiment(data.experiment, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1GetExperimentCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ResourceNotFoundException": return [3, 2];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 2];
+                    case "ValidationException": return [3, 4];
+                    case "com.amazonaws.fis#ValidationException": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1GetExperimentTemplateCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1GetExperimentTemplateCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experimentTemplate != null) {
+                    contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1GetExperimentTemplateCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ResourceNotFoundException": return [3, 2];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 2];
+                    case "ValidationException": return [3, 4];
+                    case "com.amazonaws.fis#ValidationException": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1GetTargetResourceTypeCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1GetTargetResourceTypeCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.targetResourceType != null) {
+                    contents.targetResourceType = deserializeAws_restJson1TargetResourceType(data.targetResourceType, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1GetTargetResourceTypeCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ResourceNotFoundException": return [3, 2];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 2];
+                    case "ValidationException": return [3, 4];
+                    case "com.amazonaws.fis#ValidationException": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1ListActionsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1ListActionsCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.actions != null) {
+                    contents.actions = deserializeAws_restJson1ActionSummaryList(data.actions, context);
+                }
+                if (data.nextToken != null) {
+                    contents.nextToken = __expectString(data.nextToken);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1ListActionsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ValidationException": return [3, 2];
+                    case "com.amazonaws.fis#ValidationException": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1ListExperimentsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1ListExperimentsCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experiments != null) {
+                    contents.experiments = deserializeAws_restJson1ExperimentSummaryList(data.experiments, context);
+                }
+                if (data.nextToken != null) {
+                    contents.nextToken = __expectString(data.nextToken);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1ListExperimentsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ValidationException": return [3, 2];
+                    case "com.amazonaws.fis#ValidationException": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1ListExperimentTemplatesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1ListExperimentTemplatesCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experimentTemplates != null) {
+                    contents.experimentTemplates = deserializeAws_restJson1ExperimentTemplateSummaryList(data.experimentTemplates, context);
+                }
+                if (data.nextToken != null) {
+                    contents.nextToken = __expectString(data.nextToken);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1ListExperimentTemplatesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ValidationException": return [3, 2];
+                    case "com.amazonaws.fis#ValidationException": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1ListTagsForResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1ListTagsForResourceCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.tags != null) {
+                    contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1ListTagsForResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1ListTargetResourceTypesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1ListTargetResourceTypesCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.nextToken != null) {
+                    contents.nextToken = __expectString(data.nextToken);
+                }
+                if (data.targetResourceTypes != null) {
+                    contents.targetResourceTypes = deserializeAws_restJson1TargetResourceTypeSummaryList(data.targetResourceTypes, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1ListTargetResourceTypesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ValidationException": return [3, 2];
+                    case "com.amazonaws.fis#ValidationException": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1StartExperimentCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1StartExperimentCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experiment != null) {
+                    contents.experiment = deserializeAws_restJson1Experiment(data.experiment, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1StartExperimentCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ConflictException": return [3, 2];
+                    case "com.amazonaws.fis#ConflictException": return [3, 2];
+                    case "ResourceNotFoundException": return [3, 4];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 4];
+                    case "ServiceQuotaExceededException": return [3, 6];
+                    case "com.amazonaws.fis#ServiceQuotaExceededException": return [3, 6];
+                    case "ValidationException": return [3, 8];
+                    case "com.amazonaws.fis#ValidationException": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 11;
+            case 11: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1StopExperimentCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1StopExperimentCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experiment != null) {
+                    contents.experiment = deserializeAws_restJson1Experiment(data.experiment, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1StopExperimentCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ResourceNotFoundException": return [3, 2];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 2];
+                    case "ValidationException": return [3, 4];
+                    case "com.amazonaws.fis#ValidationException": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1TagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1TagResourceCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1TagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1UntagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1UntagResourceCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1UntagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                return [2];
+        }
+    });
+}); };
+export var deserializeAws_restJson1UpdateExperimentTemplateCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1UpdateExperimentTemplateCommandError(output, context)];
+                }
+                contents = map({
+                    $metadata: deserializeMetadata(output),
+                });
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.experimentTemplate != null) {
+                    contents.experimentTemplate = deserializeAws_restJson1ExperimentTemplate(data.experimentTemplate, context);
+                }
+                return [2, contents];
+        }
+    });
+}); };
+var deserializeAws_restJson1UpdateExperimentTemplateCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ResourceNotFoundException": return [3, 2];
+                    case "com.amazonaws.fis#ResourceNotFoundException": return [3, 2];
+                    case "ServiceQuotaExceededException": return [3, 4];
+                    case "com.amazonaws.fis#ServiceQuotaExceededException": return [3, 4];
+                    case "ValidationException": return [3, 6];
+                    case "com.amazonaws.fis#ValidationException": return [3, 6];
+                }
+                return [3, 8];
+            case 2: return [4, deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 9;
+            case 9: return [2];
+        }
+    });
+}); };
+var map = __map;
+var deserializeAws_restJson1ConflictExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = map({});
+        data = parsedOutput.body;
+        if (data.message != null) {
+            contents.message = __expectString(data.message);
+        }
+        exception = new ConflictException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
+var deserializeAws_restJson1ResourceNotFoundExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = map({});
+        data = parsedOutput.body;
+        if (data.message != null) {
+            contents.message = __expectString(data.message);
+        }
+        exception = new ResourceNotFoundException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
+var deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = map({});
+        data = parsedOutput.body;
+        if (data.message != null) {
+            contents.message = __expectString(data.message);
+        }
+        exception = new ServiceQuotaExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
+var deserializeAws_restJson1ValidationExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = map({});
+        data = parsedOutput.body;
+        if (data.message != null) {
+            contents.message = __expectString(data.message);
+        }
+        exception = new ValidationException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
+var serializeAws_restJson1CreateExperimentTemplateActionInput = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign({}, (input.actionId != null && { actionId: input.actionId })), (input.description != null && { description: input.description })), (input.parameters != null && {
+        parameters: serializeAws_restJson1ExperimentTemplateActionParameterMap(input.parameters, context),
+    })), (input.startAfter != null && {
+        startAfter: serializeAws_restJson1ExperimentTemplateActionStartAfterList(input.startAfter, context),
+    })), (input.targets != null && {
+        targets: serializeAws_restJson1ExperimentTemplateActionTargetMap(input.targets, context),
+    }));
+};
+var serializeAws_restJson1CreateExperimentTemplateActionInputMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: serializeAws_restJson1CreateExperimentTemplateActionInput(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = serializeAws_restJson1CreateExperimentTemplateActionInput(value, context), _b));
     }, {});
 };
-const serializeAws_restJson1CreateExperimentTemplateLogConfigurationInput = (input, context) => {
-    return {
-        ...(input.cloudWatchLogsConfiguration != null && {
-            cloudWatchLogsConfiguration: serializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfigurationInput(input.cloudWatchLogsConfiguration, context),
-        }),
-        ...(input.logSchemaVersion != null && { logSchemaVersion: input.logSchemaVersion }),
-        ...(input.s3Configuration != null && {
-            s3Configuration: serializeAws_restJson1ExperimentTemplateS3LogConfigurationInput(input.s3Configuration, context),
-        }),
-    };
+var serializeAws_restJson1CreateExperimentTemplateLogConfigurationInput = function (input, context) {
+    return __assign(__assign(__assign({}, (input.cloudWatchLogsConfiguration != null && {
+        cloudWatchLogsConfiguration: serializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfigurationInput(input.cloudWatchLogsConfiguration, context),
+    })), (input.logSchemaVersion != null && { logSchemaVersion: input.logSchemaVersion })), (input.s3Configuration != null && {
+        s3Configuration: serializeAws_restJson1ExperimentTemplateS3LogConfigurationInput(input.s3Configuration, context),
+    }));
 };
-const serializeAws_restJson1CreateExperimentTemplateStopConditionInput = (input, context) => {
-    return {
-        ...(input.source != null && { source: input.source }),
-        ...(input.value != null && { value: input.value }),
-    };
+var serializeAws_restJson1CreateExperimentTemplateStopConditionInput = function (input, context) {
+    return __assign(__assign({}, (input.source != null && { source: input.source })), (input.value != null && { value: input.value }));
 };
-const serializeAws_restJson1CreateExperimentTemplateStopConditionInputList = (input, context) => {
+var serializeAws_restJson1CreateExperimentTemplateStopConditionInputList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return serializeAws_restJson1CreateExperimentTemplateStopConditionInput(entry, context);
     });
 };
-const serializeAws_restJson1CreateExperimentTemplateTargetInput = (input, context) => {
-    return {
-        ...(input.filters != null && {
-            filters: serializeAws_restJson1ExperimentTemplateTargetFilterInputList(input.filters, context),
-        }),
-        ...(input.parameters != null && {
-            parameters: serializeAws_restJson1ExperimentTemplateTargetParameterMap(input.parameters, context),
-        }),
-        ...(input.resourceArns != null && {
-            resourceArns: serializeAws_restJson1ResourceArnList(input.resourceArns, context),
-        }),
-        ...(input.resourceTags != null && { resourceTags: serializeAws_restJson1TagMap(input.resourceTags, context) }),
-        ...(input.resourceType != null && { resourceType: input.resourceType }),
-        ...(input.selectionMode != null && { selectionMode: input.selectionMode }),
-    };
+var serializeAws_restJson1CreateExperimentTemplateTargetInput = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.filters != null && {
+        filters: serializeAws_restJson1ExperimentTemplateTargetFilterInputList(input.filters, context),
+    })), (input.parameters != null && {
+        parameters: serializeAws_restJson1ExperimentTemplateTargetParameterMap(input.parameters, context),
+    })), (input.resourceArns != null && {
+        resourceArns: serializeAws_restJson1ResourceArnList(input.resourceArns, context),
+    })), (input.resourceTags != null && { resourceTags: serializeAws_restJson1TagMap(input.resourceTags, context) })), (input.resourceType != null && { resourceType: input.resourceType })), (input.selectionMode != null && { selectionMode: input.selectionMode }));
 };
-const serializeAws_restJson1CreateExperimentTemplateTargetInputMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+var serializeAws_restJson1CreateExperimentTemplateTargetInputMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: serializeAws_restJson1CreateExperimentTemplateTargetInput(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = serializeAws_restJson1CreateExperimentTemplateTargetInput(value, context), _b));
     }, {});
 };
-const serializeAws_restJson1ExperimentTemplateActionParameterMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+var serializeAws_restJson1ExperimentTemplateActionParameterMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: value,
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b));
     }, {});
 };
-const serializeAws_restJson1ExperimentTemplateActionStartAfterList = (input, context) => {
+var serializeAws_restJson1ExperimentTemplateActionStartAfterList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return entry;
     });
 };
-const serializeAws_restJson1ExperimentTemplateActionTargetMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+var serializeAws_restJson1ExperimentTemplateActionTargetMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: value,
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b));
     }, {});
 };
-const serializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfigurationInput = (input, context) => {
-    return {
-        ...(input.logGroupArn != null && { logGroupArn: input.logGroupArn }),
-    };
+var serializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfigurationInput = function (input, context) {
+    return __assign({}, (input.logGroupArn != null && { logGroupArn: input.logGroupArn }));
 };
-const serializeAws_restJson1ExperimentTemplateS3LogConfigurationInput = (input, context) => {
-    return {
-        ...(input.bucketName != null && { bucketName: input.bucketName }),
-        ...(input.prefix != null && { prefix: input.prefix }),
-    };
+var serializeAws_restJson1ExperimentTemplateS3LogConfigurationInput = function (input, context) {
+    return __assign(__assign({}, (input.bucketName != null && { bucketName: input.bucketName })), (input.prefix != null && { prefix: input.prefix }));
 };
-const serializeAws_restJson1ExperimentTemplateTargetFilterInputList = (input, context) => {
+var serializeAws_restJson1ExperimentTemplateTargetFilterInputList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return serializeAws_restJson1ExperimentTemplateTargetInputFilter(entry, context);
     });
 };
-const serializeAws_restJson1ExperimentTemplateTargetFilterValues = (input, context) => {
+var serializeAws_restJson1ExperimentTemplateTargetFilterValues = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return entry;
     });
 };
-const serializeAws_restJson1ExperimentTemplateTargetInputFilter = (input, context) => {
-    return {
-        ...(input.path != null && { path: input.path }),
-        ...(input.values != null && {
-            values: serializeAws_restJson1ExperimentTemplateTargetFilterValues(input.values, context),
-        }),
-    };
+var serializeAws_restJson1ExperimentTemplateTargetInputFilter = function (input, context) {
+    return __assign(__assign({}, (input.path != null && { path: input.path })), (input.values != null && {
+        values: serializeAws_restJson1ExperimentTemplateTargetFilterValues(input.values, context),
+    }));
 };
-const serializeAws_restJson1ExperimentTemplateTargetParameterMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+var serializeAws_restJson1ExperimentTemplateTargetParameterMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: value,
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b));
     }, {});
 };
-const serializeAws_restJson1ResourceArnList = (input, context) => {
+var serializeAws_restJson1ResourceArnList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return entry;
     });
 };
-const serializeAws_restJson1TagMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+var serializeAws_restJson1TagMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: value,
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = value, _b));
     }, {});
 };
-const serializeAws_restJson1UpdateExperimentTemplateActionInputItem = (input, context) => {
-    return {
-        ...(input.actionId != null && { actionId: input.actionId }),
-        ...(input.description != null && { description: input.description }),
-        ...(input.parameters != null && {
-            parameters: serializeAws_restJson1ExperimentTemplateActionParameterMap(input.parameters, context),
-        }),
-        ...(input.startAfter != null && {
-            startAfter: serializeAws_restJson1ExperimentTemplateActionStartAfterList(input.startAfter, context),
-        }),
-        ...(input.targets != null && {
-            targets: serializeAws_restJson1ExperimentTemplateActionTargetMap(input.targets, context),
-        }),
-    };
-};
-const serializeAws_restJson1UpdateExperimentTemplateActionInputMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+var serializeAws_restJson1UpdateExperimentTemplateActionInputItem = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign({}, (input.actionId != null && { actionId: input.actionId })), (input.description != null && { description: input.description })), (input.parameters != null && {
+        parameters: serializeAws_restJson1ExperimentTemplateActionParameterMap(input.parameters, context),
+    })), (input.startAfter != null && {
+        startAfter: serializeAws_restJson1ExperimentTemplateActionStartAfterList(input.startAfter, context),
+    })), (input.targets != null && {
+        targets: serializeAws_restJson1ExperimentTemplateActionTargetMap(input.targets, context),
+    }));
+};
+var serializeAws_restJson1UpdateExperimentTemplateActionInputMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: serializeAws_restJson1UpdateExperimentTemplateActionInputItem(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = serializeAws_restJson1UpdateExperimentTemplateActionInputItem(value, context), _b));
     }, {});
 };
-const serializeAws_restJson1UpdateExperimentTemplateLogConfigurationInput = (input, context) => {
-    return {
-        ...(input.cloudWatchLogsConfiguration != null && {
-            cloudWatchLogsConfiguration: serializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfigurationInput(input.cloudWatchLogsConfiguration, context),
-        }),
-        ...(input.logSchemaVersion != null && { logSchemaVersion: input.logSchemaVersion }),
-        ...(input.s3Configuration != null && {
-            s3Configuration: serializeAws_restJson1ExperimentTemplateS3LogConfigurationInput(input.s3Configuration, context),
-        }),
-    };
+var serializeAws_restJson1UpdateExperimentTemplateLogConfigurationInput = function (input, context) {
+    return __assign(__assign(__assign({}, (input.cloudWatchLogsConfiguration != null && {
+        cloudWatchLogsConfiguration: serializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfigurationInput(input.cloudWatchLogsConfiguration, context),
+    })), (input.logSchemaVersion != null && { logSchemaVersion: input.logSchemaVersion })), (input.s3Configuration != null && {
+        s3Configuration: serializeAws_restJson1ExperimentTemplateS3LogConfigurationInput(input.s3Configuration, context),
+    }));
 };
-const serializeAws_restJson1UpdateExperimentTemplateStopConditionInput = (input, context) => {
-    return {
-        ...(input.source != null && { source: input.source }),
-        ...(input.value != null && { value: input.value }),
-    };
+var serializeAws_restJson1UpdateExperimentTemplateStopConditionInput = function (input, context) {
+    return __assign(__assign({}, (input.source != null && { source: input.source })), (input.value != null && { value: input.value }));
 };
-const serializeAws_restJson1UpdateExperimentTemplateStopConditionInputList = (input, context) => {
+var serializeAws_restJson1UpdateExperimentTemplateStopConditionInputList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return serializeAws_restJson1UpdateExperimentTemplateStopConditionInput(entry, context);
     });
 };
-const serializeAws_restJson1UpdateExperimentTemplateTargetInput = (input, context) => {
-    return {
-        ...(input.filters != null && {
-            filters: serializeAws_restJson1ExperimentTemplateTargetFilterInputList(input.filters, context),
-        }),
-        ...(input.parameters != null && {
-            parameters: serializeAws_restJson1ExperimentTemplateTargetParameterMap(input.parameters, context),
-        }),
-        ...(input.resourceArns != null && {
-            resourceArns: serializeAws_restJson1ResourceArnList(input.resourceArns, context),
-        }),
-        ...(input.resourceTags != null && { resourceTags: serializeAws_restJson1TagMap(input.resourceTags, context) }),
-        ...(input.resourceType != null && { resourceType: input.resourceType }),
-        ...(input.selectionMode != null && { selectionMode: input.selectionMode }),
-    };
+var serializeAws_restJson1UpdateExperimentTemplateTargetInput = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.filters != null && {
+        filters: serializeAws_restJson1ExperimentTemplateTargetFilterInputList(input.filters, context),
+    })), (input.parameters != null && {
+        parameters: serializeAws_restJson1ExperimentTemplateTargetParameterMap(input.parameters, context),
+    })), (input.resourceArns != null && {
+        resourceArns: serializeAws_restJson1ResourceArnList(input.resourceArns, context),
+    })), (input.resourceTags != null && { resourceTags: serializeAws_restJson1TagMap(input.resourceTags, context) })), (input.resourceType != null && { resourceType: input.resourceType })), (input.selectionMode != null && { selectionMode: input.selectionMode }));
 };
-const serializeAws_restJson1UpdateExperimentTemplateTargetInputMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
+var serializeAws_restJson1UpdateExperimentTemplateTargetInputMap = function (input, context) {
+    return Object.entries(input).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: serializeAws_restJson1UpdateExperimentTemplateTargetInput(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = serializeAws_restJson1UpdateExperimentTemplateTargetInput(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1Action = (output, context) => {
+var deserializeAws_restJson1Action = function (output, context) {
     return {
         description: __expectString(output.description),
         id: __expectString(output.id),
@@ -1188,24 +1575,23 @@ const deserializeAws_restJson1Action = (output, context) => {
         targets: output.targets != null ? deserializeAws_restJson1ActionTargetMap(output.targets, context) : undefined,
     };
 };
-const deserializeAws_restJson1ActionParameter = (output, context) => {
+var deserializeAws_restJson1ActionParameter = function (output, context) {
     return {
         description: __expectString(output.description),
         required: __expectBoolean(output.required),
     };
 };
-const deserializeAws_restJson1ActionParameterMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ActionParameterMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1ActionParameter(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_restJson1ActionParameter(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1ActionSummary = (output, context) => {
+var deserializeAws_restJson1ActionSummary = function (output, context) {
     return {
         description: __expectString(output.description),
         id: __expectString(output.id),
@@ -1213,10 +1599,10 @@ const deserializeAws_restJson1ActionSummary = (output, context) => {
         targets: output.targets != null ? deserializeAws_restJson1ActionTargetMap(output.targets, context) : undefined,
     };
 };
-const deserializeAws_restJson1ActionSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ActionSummaryList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1224,23 +1610,22 @@ const deserializeAws_restJson1ActionSummaryList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1ActionTarget = (output, context) => {
+var deserializeAws_restJson1ActionTarget = function (output, context) {
     return {
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_restJson1ActionTargetMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ActionTargetMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1ActionTarget(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_restJson1ActionTarget(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1Experiment = (output, context) => {
+var deserializeAws_restJson1Experiment = function (output, context) {
     return {
         actions: output.actions != null ? deserializeAws_restJson1ExperimentActionMap(output.actions, context) : undefined,
         creationTime: output.creationTime != null
@@ -1262,7 +1647,7 @@ const deserializeAws_restJson1Experiment = (output, context) => {
         targets: output.targets != null ? deserializeAws_restJson1ExperimentTargetMap(output.targets, context) : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentAction = (output, context) => {
+var deserializeAws_restJson1ExperimentAction = function (output, context) {
     return {
         actionId: __expectString(output.actionId),
         description: __expectString(output.description),
@@ -1278,32 +1663,30 @@ const deserializeAws_restJson1ExperimentAction = (output, context) => {
         targets: output.targets != null ? deserializeAws_restJson1ExperimentActionTargetMap(output.targets, context) : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentActionMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentActionMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1ExperimentAction(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_restJson1ExperimentAction(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentActionParameterMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentActionParameterMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentActionStartAfterList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentActionStartAfterList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1311,29 +1694,28 @@ const deserializeAws_restJson1ExperimentActionStartAfterList = (output, context)
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentActionState = (output, context) => {
+var deserializeAws_restJson1ExperimentActionState = function (output, context) {
     return {
         reason: __expectString(output.reason),
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1ExperimentActionTargetMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentActionTargetMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentCloudWatchLogsLogConfiguration = (output, context) => {
+var deserializeAws_restJson1ExperimentCloudWatchLogsLogConfiguration = function (output, context) {
     return {
         logGroupArn: __expectString(output.logGroupArn),
     };
 };
-const deserializeAws_restJson1ExperimentLogConfiguration = (output, context) => {
+var deserializeAws_restJson1ExperimentLogConfiguration = function (output, context) {
     return {
         cloudWatchLogsConfiguration: output.cloudWatchLogsConfiguration != null
             ? deserializeAws_restJson1ExperimentCloudWatchLogsLogConfiguration(output.cloudWatchLogsConfiguration, context)
@@ -1344,28 +1726,28 @@ const deserializeAws_restJson1ExperimentLogConfiguration = (output, context) =>
             : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentS3LogConfiguration = (output, context) => {
+var deserializeAws_restJson1ExperimentS3LogConfiguration = function (output, context) {
     return {
         bucketName: __expectString(output.bucketName),
         prefix: __expectString(output.prefix),
     };
 };
-const deserializeAws_restJson1ExperimentState = (output, context) => {
+var deserializeAws_restJson1ExperimentState = function (output, context) {
     return {
         reason: __expectString(output.reason),
         status: __expectString(output.status),
     };
 };
-const deserializeAws_restJson1ExperimentStopCondition = (output, context) => {
+var deserializeAws_restJson1ExperimentStopCondition = function (output, context) {
     return {
         source: __expectString(output.source),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_restJson1ExperimentStopConditionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentStopConditionList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1373,7 +1755,7 @@ const deserializeAws_restJson1ExperimentStopConditionList = (output, context) =>
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentSummary = (output, context) => {
+var deserializeAws_restJson1ExperimentSummary = function (output, context) {
     return {
         creationTime: output.creationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationTime)))
@@ -1384,10 +1766,10 @@ const deserializeAws_restJson1ExperimentSummary = (output, context) => {
         tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentSummaryList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1395,7 +1777,7 @@ const deserializeAws_restJson1ExperimentSummaryList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTarget = (output, context) => {
+var deserializeAws_restJson1ExperimentTarget = function (output, context) {
     return {
         filters: output.filters != null ? deserializeAws_restJson1ExperimentTargetFilterList(output.filters, context) : undefined,
         parameters: output.parameters != null
@@ -1407,16 +1789,16 @@ const deserializeAws_restJson1ExperimentTarget = (output, context) => {
         selectionMode: __expectString(output.selectionMode),
     };
 };
-const deserializeAws_restJson1ExperimentTargetFilter = (output, context) => {
+var deserializeAws_restJson1ExperimentTargetFilter = function (output, context) {
     return {
         path: __expectString(output.path),
         values: output.values != null ? deserializeAws_restJson1ExperimentTargetFilterValues(output.values, context) : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentTargetFilterList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentTargetFilterList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1424,10 +1806,10 @@ const deserializeAws_restJson1ExperimentTargetFilterList = (output, context) =>
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTargetFilterValues = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentTargetFilterValues = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1435,29 +1817,27 @@ const deserializeAws_restJson1ExperimentTargetFilterValues = (output, context) =
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTargetMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentTargetMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1ExperimentTarget(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_restJson1ExperimentTarget(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentTargetParameterMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentTargetParameterMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentTemplate = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplate = function (output, context) {
     return {
         actions: output.actions != null ? deserializeAws_restJson1ExperimentTemplateActionMap(output.actions, context) : undefined,
         creationTime: output.creationTime != null
@@ -1479,7 +1859,7 @@ const deserializeAws_restJson1ExperimentTemplate = (output, context) => {
         targets: output.targets != null ? deserializeAws_restJson1ExperimentTemplateTargetMap(output.targets, context) : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentTemplateAction = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateAction = function (output, context) {
     return {
         actionId: __expectString(output.actionId),
         description: __expectString(output.description),
@@ -1494,32 +1874,30 @@ const deserializeAws_restJson1ExperimentTemplateAction = (output, context) => {
             : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentTemplateActionMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentTemplateActionMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1ExperimentTemplateAction(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_restJson1ExperimentTemplateAction(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentTemplateActionParameterMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentTemplateActionParameterMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentTemplateActionStartAfterList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentTemplateActionStartAfterList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1527,23 +1905,22 @@ const deserializeAws_restJson1ExperimentTemplateActionStartAfterList = (output,
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTemplateActionTargetMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentTemplateActionTargetMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfiguration = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfiguration = function (output, context) {
     return {
         logGroupArn: __expectString(output.logGroupArn),
     };
 };
-const deserializeAws_restJson1ExperimentTemplateLogConfiguration = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateLogConfiguration = function (output, context) {
     return {
         cloudWatchLogsConfiguration: output.cloudWatchLogsConfiguration != null
             ? deserializeAws_restJson1ExperimentTemplateCloudWatchLogsLogConfiguration(output.cloudWatchLogsConfiguration, context)
@@ -1554,22 +1931,22 @@ const deserializeAws_restJson1ExperimentTemplateLogConfiguration = (output, cont
             : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentTemplateS3LogConfiguration = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateS3LogConfiguration = function (output, context) {
     return {
         bucketName: __expectString(output.bucketName),
         prefix: __expectString(output.prefix),
     };
 };
-const deserializeAws_restJson1ExperimentTemplateStopCondition = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateStopCondition = function (output, context) {
     return {
         source: __expectString(output.source),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_restJson1ExperimentTemplateStopConditionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentTemplateStopConditionList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1577,7 +1954,7 @@ const deserializeAws_restJson1ExperimentTemplateStopConditionList = (output, con
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTemplateSummary = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateSummary = function (output, context) {
     return {
         creationTime: output.creationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationTime)))
@@ -1590,10 +1967,10 @@ const deserializeAws_restJson1ExperimentTemplateSummary = (output, context) => {
         tags: output.tags != null ? deserializeAws_restJson1TagMap(output.tags, context) : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentTemplateSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentTemplateSummaryList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1601,7 +1978,7 @@ const deserializeAws_restJson1ExperimentTemplateSummaryList = (output, context)
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTemplateTarget = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateTarget = function (output, context) {
     return {
         filters: output.filters != null
             ? deserializeAws_restJson1ExperimentTemplateTargetFilterList(output.filters, context)
@@ -1615,7 +1992,7 @@ const deserializeAws_restJson1ExperimentTemplateTarget = (output, context) => {
         selectionMode: __expectString(output.selectionMode),
     };
 };
-const deserializeAws_restJson1ExperimentTemplateTargetFilter = (output, context) => {
+var deserializeAws_restJson1ExperimentTemplateTargetFilter = function (output, context) {
     return {
         path: __expectString(output.path),
         values: output.values != null
@@ -1623,10 +2000,10 @@ const deserializeAws_restJson1ExperimentTemplateTargetFilter = (output, context)
             : undefined,
     };
 };
-const deserializeAws_restJson1ExperimentTemplateTargetFilterList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentTemplateTargetFilterList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1634,10 +2011,10 @@ const deserializeAws_restJson1ExperimentTemplateTargetFilterList = (output, cont
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTemplateTargetFilterValues = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ExperimentTemplateTargetFilterValues = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1645,32 +2022,30 @@ const deserializeAws_restJson1ExperimentTemplateTargetFilterValues = (output, co
     });
     return retVal;
 };
-const deserializeAws_restJson1ExperimentTemplateTargetMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentTemplateTargetMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1ExperimentTemplateTarget(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_restJson1ExperimentTemplateTarget(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1ExperimentTemplateTargetParameterMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1ExperimentTemplateTargetParameterMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
     }, {});
 };
-const deserializeAws_restJson1ResourceArnList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1ResourceArnList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1678,18 +2053,17 @@ const deserializeAws_restJson1ResourceArnList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1TagMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1TagMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: __expectString(value),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = __expectString(value), _b));
     }, {});
 };
-const deserializeAws_restJson1TargetResourceType = (output, context) => {
+var deserializeAws_restJson1TargetResourceType = function (output, context) {
     return {
         description: __expectString(output.description),
         parameters: output.parameters != null
@@ -1698,33 +2072,32 @@ const deserializeAws_restJson1TargetResourceType = (output, context) => {
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_restJson1TargetResourceTypeParameter = (output, context) => {
+var deserializeAws_restJson1TargetResourceTypeParameter = function (output, context) {
     return {
         description: __expectString(output.description),
         required: __expectBoolean(output.required),
     };
 };
-const deserializeAws_restJson1TargetResourceTypeParameterMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
+var deserializeAws_restJson1TargetResourceTypeParameterMap = function (output, context) {
+    return Object.entries(output).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
         if (value === null) {
             return acc;
         }
-        return {
-            ...acc,
-            [key]: deserializeAws_restJson1TargetResourceTypeParameter(value, context),
-        };
+        return __assign(__assign({}, acc), (_b = {}, _b[key] = deserializeAws_restJson1TargetResourceTypeParameter(value, context), _b));
     }, {});
 };
-const deserializeAws_restJson1TargetResourceTypeSummary = (output, context) => {
+var deserializeAws_restJson1TargetResourceTypeSummary = function (output, context) {
     return {
         description: __expectString(output.description),
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_restJson1TargetResourceTypeSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_restJson1TargetResourceTypeSummaryList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1732,39 +2105,57 @@ const deserializeAws_restJson1TargetResourceTypeSummaryList = (output, context)
     });
     return retVal;
 };
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const collectBody = (streamBody = new Uint8Array(), context) => {
+var deserializeMetadata = function (output) {
+    var _a, _b;
+    return ({
+        httpStatusCode: output.statusCode,
+        requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"],
+        extendedRequestId: output.headers["x-amz-id-2"],
+        cfId: output.headers["x-amz-cf-id"],
+    });
+};
+var collectBody = function (streamBody, context) {
+    if (streamBody === void 0) { streamBody = new Uint8Array(); }
     if (streamBody instanceof Uint8Array) {
         return Promise.resolve(streamBody);
     }
     return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
 };
-const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-const isSerializableHeaderValue = (value) => value !== undefined &&
-    value !== null &&
-    value !== "" &&
-    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
-    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
-const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
-    if (encoded.length) {
-        return JSON.parse(encoded);
-    }
-    return {};
-});
-const parseErrorBody = async (errorBody, context) => {
-    const value = await parseBody(errorBody, context);
-    value.message = value.message ?? value.Message;
-    return value;
-};
-const loadRestJsonErrorCode = (output, data) => {
-    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
-    const sanitizeErrorCode = (rawValue) => {
-        let cleanValue = rawValue;
+var collectBodyString = function (streamBody, context) {
+    return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
+};
+var isSerializableHeaderValue = function (value) {
+    return value !== undefined &&
+        value !== null &&
+        value !== "" &&
+        (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
+        (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+};
+var parseBody = function (streamBody, context) {
+    return collectBodyString(streamBody, context).then(function (encoded) {
+        if (encoded.length) {
+            return JSON.parse(encoded);
+        }
+        return {};
+    });
+};
+var parseErrorBody = function (errorBody, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var value;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4, parseBody(errorBody, context)];
+            case 1:
+                value = _b.sent();
+                value.message = (_a = value.message) !== null && _a !== void 0 ? _a : value.Message;
+                return [2, value];
+        }
+    });
+}); };
+var loadRestJsonErrorCode = function (output, data) {
+    var findKey = function (object, key) { return Object.keys(object).find(function (k) { return k.toLowerCase() === key.toLowerCase(); }); };
+    var sanitizeErrorCode = function (rawValue) {
+        var cleanValue = rawValue;
         if (typeof cleanValue === "number") {
             cleanValue = cleanValue.toString();
         }
@@ -1779,7 +2170,7 @@ const loadRestJsonErrorCode = (output, data) => {
         }
         return cleanValue;
     };
-    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    var headerKey = findKey(output.headers, "x-amzn-errortype");
     if (headerKey !== undefined) {
         return sanitizeErrorCode(output.headers[headerKey]);
     }