@aws-sdk/client-location 3.276.0 → 3.278.0

package/dist-es/protocols/Aws_restJson1.js

@@ -333,6 +333,40 @@ export const serializeAws_restJson1CreateGeofenceCollectionCommand = async (inpu
         body,
     });
 };
+export const serializeAws_restJson1CreateKeyCommand = 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 || ""}` + "/metadata/v0/keys";
+    let body;
+    body = JSON.stringify({
+        ...(input.Description != null && { Description: input.Description }),
+        ...(input.ExpireTime != null && { ExpireTime: input.ExpireTime.toISOString().split(".")[0] + "Z" }),
+        ...(input.KeyName != null && { KeyName: input.KeyName }),
+        ...(input.NoExpiry != null && { NoExpiry: input.NoExpiry }),
+        ...(input.Restrictions != null && {
+            Restrictions: serializeAws_restJson1ApiKeyRestrictions(input.Restrictions, context),
+        }),
+        ...(input.Tags != null && { Tags: serializeAws_restJson1TagMap(input.Tags, context) }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "metadata." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1CreateMapCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -488,6 +522,29 @@ export const serializeAws_restJson1DeleteGeofenceCollectionCommand = async (inpu
         body,
     });
 };
+export const serializeAws_restJson1DeleteKeyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata/v0/keys/{KeyName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "KeyName", () => input.KeyName, "{KeyName}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "metadata." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1DeleteMapCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -604,6 +661,29 @@ export const serializeAws_restJson1DescribeGeofenceCollectionCommand = async (in
         body,
     });
 };
+export const serializeAws_restJson1DescribeKeyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata/v0/keys/{KeyName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "KeyName", () => input.KeyName, "{KeyName}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "metadata." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1DescribeMapCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -816,6 +896,9 @@ export const serializeAws_restJson1GetMapGlyphsCommand = async (input, context)
     resolvedPath = __resolvedPath(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
     resolvedPath = __resolvedPath(resolvedPath, input, "FontStack", () => input.FontStack, "{FontStack}", false);
     resolvedPath = __resolvedPath(resolvedPath, input, "FontUnicodeRange", () => input.FontUnicodeRange, "{FontUnicodeRange}", false);
+    const query = map({
+        key: [, input.Key],
+    });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -831,6 +914,7 @@ export const serializeAws_restJson1GetMapGlyphsCommand = async (input, context)
         method: "GET",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
@@ -841,6 +925,9 @@ export const serializeAws_restJson1GetMapSpritesCommand = async (input, context)
         "/maps/v0/maps/{MapName}/sprites/{FileName}";
     resolvedPath = __resolvedPath(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
     resolvedPath = __resolvedPath(resolvedPath, input, "FileName", () => input.FileName, "{FileName}", false);
+    const query = map({
+        key: [, input.Key],
+    });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -856,6 +943,7 @@ export const serializeAws_restJson1GetMapSpritesCommand = async (input, context)
         method: "GET",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
@@ -864,6 +952,9 @@ export const serializeAws_restJson1GetMapStyleDescriptorCommand = async (input,
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/maps/{MapName}/style-descriptor";
     resolvedPath = __resolvedPath(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
+    const query = map({
+        key: [, input.Key],
+    });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -879,6 +970,7 @@ export const serializeAws_restJson1GetMapStyleDescriptorCommand = async (input,
         method: "GET",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
@@ -890,6 +982,9 @@ export const serializeAws_restJson1GetMapTileCommand = async (input, context) =>
     resolvedPath = __resolvedPath(resolvedPath, input, "Z", () => input.Z, "{Z}", false);
     resolvedPath = __resolvedPath(resolvedPath, input, "X", () => input.X, "{X}", false);
     resolvedPath = __resolvedPath(resolvedPath, input, "Y", () => input.Y, "{Y}", false);
+    const query = map({
+        key: [, input.Key],
+    });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -905,6 +1000,7 @@ export const serializeAws_restJson1GetMapTileCommand = async (input, context) =>
         method: "GET",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
@@ -1025,6 +1121,35 @@ export const serializeAws_restJson1ListGeofencesCommand = async (input, context)
         body,
     });
 };
+export const serializeAws_restJson1ListKeysCommand = 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 || ""}` + "/metadata/v0/list-keys";
+    let body;
+    body = JSON.stringify({
+        ...(input.Filter != null && { Filter: serializeAws_restJson1ApiKeyFilter(input.Filter, context) }),
+        ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
+        ...(input.NextToken != null && { NextToken: input.NextToken }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "metadata." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1ListMapsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1412,6 +1537,40 @@ export const serializeAws_restJson1UpdateGeofenceCollectionCommand = async (inpu
         body,
     });
 };
+export const serializeAws_restJson1UpdateKeyCommand = 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 || ""}` + "/metadata/v0/keys/{KeyName}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "KeyName", () => input.KeyName, "{KeyName}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.Description != null && { Description: input.Description }),
+        ...(input.ExpireTime != null && { ExpireTime: input.ExpireTime.toISOString().split(".")[0] + "Z" }),
+        ...(input.ForceUpdate != null && { ForceUpdate: input.ForceUpdate }),
+        ...(input.NoExpiry != null && { NoExpiry: input.NoExpiry }),
+        ...(input.Restrictions != null && {
+            Restrictions: serializeAws_restJson1ApiKeyRestrictions(input.Restrictions, context),
+        }),
+    });
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "metadata." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1UpdateMapCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -2013,6 +2172,63 @@ const deserializeAws_restJson1CreateGeofenceCollectionCommandError = async (outp
             });
     }
 };
+export const deserializeAws_restJson1CreateKeyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateKeyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.CreateTime != null) {
+        contents.CreateTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.CreateTime));
+    }
+    if (data.Key != null) {
+        contents.Key = __expectString(data.Key);
+    }
+    if (data.KeyArn != null) {
+        contents.KeyArn = __expectString(data.KeyArn);
+    }
+    if (data.KeyName != null) {
+        contents.KeyName = __expectString(data.KeyName);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateKeyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.location#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.location#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.location#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.location#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.location#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.location#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1CreateMapCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1CreateMapCommandError(output, context);
@@ -2268,6 +2484,48 @@ const deserializeAws_restJson1DeleteGeofenceCollectionCommandError = async (outp
             });
     }
 };
+export const deserializeAws_restJson1DeleteKeyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteKeyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteKeyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.location#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.location#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.location#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.location#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.location#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1DeleteMapCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteMapCommandError(output, context);
@@ -2505,6 +2763,75 @@ const deserializeAws_restJson1DescribeGeofenceCollectionCommandError = async (ou
             });
     }
 };
+export const deserializeAws_restJson1DescribeKeyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DescribeKeyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.CreateTime != null) {
+        contents.CreateTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.CreateTime));
+    }
+    if (data.Description != null) {
+        contents.Description = __expectString(data.Description);
+    }
+    if (data.ExpireTime != null) {
+        contents.ExpireTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.ExpireTime));
+    }
+    if (data.Key != null) {
+        contents.Key = __expectString(data.Key);
+    }
+    if (data.KeyArn != null) {
+        contents.KeyArn = __expectString(data.KeyArn);
+    }
+    if (data.KeyName != null) {
+        contents.KeyName = __expectString(data.KeyName);
+    }
+    if (data.Restrictions != null) {
+        contents.Restrictions = deserializeAws_restJson1ApiKeyRestrictions(data.Restrictions, context);
+    }
+    if (data.Tags != null) {
+        contents.Tags = deserializeAws_restJson1TagMap(data.Tags, context);
+    }
+    if (data.UpdateTime != null) {
+        contents.UpdateTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.UpdateTime));
+    }
+    return contents;
+};
+const deserializeAws_restJson1DescribeKeyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.location#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.location#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.location#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.location#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.location#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1DescribeMapCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DescribeMapCommandError(output, context);
@@ -2995,6 +3322,7 @@ export const deserializeAws_restJson1GetMapGlyphsCommand = async (output, contex
     const contents = map({
         $metadata: deserializeMetadata(output),
         ContentType: [, output.headers["content-type"]],
+        CacheControl: [, output.headers["cache-control"]],
     });
     const data = await collectBody(output.body, context);
     contents.Blob = data;
@@ -3039,6 +3367,7 @@ export const deserializeAws_restJson1GetMapSpritesCommand = async (output, conte
     const contents = map({
         $metadata: deserializeMetadata(output),
         ContentType: [, output.headers["content-type"]],
+        CacheControl: [, output.headers["cache-control"]],
     });
     const data = await collectBody(output.body, context);
     contents.Blob = data;
@@ -3083,6 +3412,7 @@ export const deserializeAws_restJson1GetMapStyleDescriptorCommand = async (outpu
     const contents = map({
         $metadata: deserializeMetadata(output),
         ContentType: [, output.headers["content-type"]],
+        CacheControl: [, output.headers["cache-control"]],
     });
     const data = await collectBody(output.body, context);
     contents.Blob = data;
@@ -3127,6 +3457,7 @@ export const deserializeAws_restJson1GetMapTileCommand = async (output, context)
     const contents = map({
         $metadata: deserializeMetadata(output),
         ContentType: [, output.headers["content-type"]],
+        CacheControl: [, output.headers["cache-control"]],
     });
     const data = await collectBody(output.body, context);
     contents.Blob = data;
@@ -3347,6 +3678,51 @@ const deserializeAws_restJson1ListGeofencesCommandError = async (output, context
             });
     }
 };
+export const deserializeAws_restJson1ListKeysCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListKeysCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.Entries != null) {
+        contents.Entries = deserializeAws_restJson1ListKeysResponseEntryList(data.Entries, context);
+    }
+    if (data.NextToken != null) {
+        contents.NextToken = __expectString(data.NextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListKeysCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.location#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.location#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.location#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.location#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1ListMapsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListMapsCommandError(output, context);
@@ -3953,6 +4329,57 @@ const deserializeAws_restJson1UpdateGeofenceCollectionCommandError = async (outp
             });
     }
 };
+export const deserializeAws_restJson1UpdateKeyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateKeyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.KeyArn != null) {
+        contents.KeyArn = __expectString(data.KeyArn);
+    }
+    if (data.KeyName != null) {
+        contents.KeyName = __expectString(data.KeyName);
+    }
+    if (data.UpdateTime != null) {
+        contents.UpdateTime = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.UpdateTime));
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateKeyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.location#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.location#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.location#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.location#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.location#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1UpdateMapCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1UpdateMapCommandError(output, context);
@@ -4248,6 +4675,31 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const serializeAws_restJson1ApiKeyActionList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1ApiKeyFilter = (input, context) => {
+    return {
+        ...(input.KeyStatus != null && { KeyStatus: input.KeyStatus }),
+    };
+};
+const serializeAws_restJson1ApiKeyRestrictions = (input, context) => {
+    return {
+        ...(input.AllowActions != null && {
+            AllowActions: serializeAws_restJson1ApiKeyActionList(input.AllowActions, context),
+        }),
+        ...(input.AllowReferers != null && {
+            AllowReferers: serializeAws_restJson1RefererPatternList(input.AllowReferers, context),
+        }),
+        ...(input.AllowResources != null && {
+            AllowResources: serializeAws_restJson1GeoArnList(input.AllowResources, context),
+        }),
+    };
+};
 const serializeAws_restJson1BatchPutGeofenceRequestEntry = (input, context) => {
     return {
         ...(input.GeofenceId != null && { GeofenceId: input.GeofenceId }),
@@ -4325,6 +4777,13 @@ const serializeAws_restJson1DevicePositionUpdateList = (input, context) => {
         return serializeAws_restJson1DevicePositionUpdate(entry, context);
     });
 };
+const serializeAws_restJson1GeoArnList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
 const serializeAws_restJson1GeofenceGeometry = (input, context) => {
     return {
         ...(input.Circle != null && { Circle: serializeAws_restJson1Circle(input.Circle, context) }),
@@ -4385,6 +4844,13 @@ const serializeAws_restJson1PropertyMap = (input, context) => {
         return acc;
     }, {});
 };
+const serializeAws_restJson1RefererPatternList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
 const serializeAws_restJson1TagMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
@@ -4415,6 +4881,26 @@ const serializeAws_restJson1WaypointPositionList = (input, context) => {
         return serializeAws_restJson1Position(entry, context);
     });
 };
+const deserializeAws_restJson1ApiKeyActionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ApiKeyRestrictions = (output, context) => {
+    return {
+        AllowActions: output.AllowActions != null ? deserializeAws_restJson1ApiKeyActionList(output.AllowActions, context) : undefined,
+        AllowReferers: output.AllowReferers != null
+            ? deserializeAws_restJson1RefererPatternList(output.AllowReferers, context)
+            : undefined,
+        AllowResources: output.AllowResources != null ? deserializeAws_restJson1GeoArnList(output.AllowResources, context) : undefined,
+    };
+};
 const deserializeAws_restJson1ArnList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -4627,6 +5113,17 @@ const deserializeAws_restJson1DevicePositionList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1GeoArnList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1GeofenceGeometry = (output, context) => {
     return {
         Circle: output.Circle != null ? deserializeAws_restJson1Circle(output.Circle, context) : undefined,
@@ -4755,6 +5252,29 @@ const deserializeAws_restJson1ListGeofenceResponseEntryList = (output, context)
     });
     return retVal;
 };
+const deserializeAws_restJson1ListKeysResponseEntry = (output, context) => {
+    return {
+        CreateTime: output.CreateTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.CreateTime)) : undefined,
+        Description: __expectString(output.Description),
+        ExpireTime: output.ExpireTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.ExpireTime)) : undefined,
+        KeyName: __expectString(output.KeyName),
+        Restrictions: output.Restrictions != null
+            ? deserializeAws_restJson1ApiKeyRestrictions(output.Restrictions, context)
+            : undefined,
+        UpdateTime: output.UpdateTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.UpdateTime)) : undefined,
+    };
+};
+const deserializeAws_restJson1ListKeysResponseEntryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ListKeysResponseEntry(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1ListMapsResponseEntry = (output, context) => {
     return {
         CreateTime: output.CreateTime != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.CreateTime)) : undefined,
@@ -4903,6 +5423,17 @@ const deserializeAws_restJson1PropertyMap = (output, context) => {
         return acc;
     }, {});
 };
+const deserializeAws_restJson1RefererPatternList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1RouteMatrix = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)