@aws-sdk/client-outposts 3.42.0 → 3.46.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -1,8 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_restJson1UntagResourceCommand = exports.deserializeAws_restJson1TagResourceCommand = exports.deserializeAws_restJson1ListTagsForResourceCommand = exports.deserializeAws_restJson1ListSitesCommand = exports.deserializeAws_restJson1ListOutpostsCommand = exports.deserializeAws_restJson1GetOutpostInstanceTypesCommand = exports.deserializeAws_restJson1GetOutpostCommand = exports.deserializeAws_restJson1DeleteSiteCommand = exports.deserializeAws_restJson1DeleteOutpostCommand = exports.deserializeAws_restJson1CreateOutpostCommand = exports.deserializeAws_restJson1CreateOrderCommand = exports.serializeAws_restJson1UntagResourceCommand = exports.serializeAws_restJson1TagResourceCommand = exports.serializeAws_restJson1ListTagsForResourceCommand = exports.serializeAws_restJson1ListSitesCommand = exports.serializeAws_restJson1ListOutpostsCommand = exports.serializeAws_restJson1GetOutpostInstanceTypesCommand = exports.serializeAws_restJson1GetOutpostCommand = exports.serializeAws_restJson1DeleteSiteCommand = exports.serializeAws_restJson1DeleteOutpostCommand = exports.serializeAws_restJson1CreateOutpostCommand = exports.serializeAws_restJson1CreateOrderCommand = void 0;
+exports.deserializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand = exports.deserializeAws_restJson1UpdateSiteAddressCommand = exports.deserializeAws_restJson1UpdateSiteCommand = exports.deserializeAws_restJson1UpdateOutpostCommand = exports.deserializeAws_restJson1UntagResourceCommand = exports.deserializeAws_restJson1TagResourceCommand = exports.deserializeAws_restJson1ListTagsForResourceCommand = exports.deserializeAws_restJson1ListSitesCommand = exports.deserializeAws_restJson1ListOutpostsCommand = exports.deserializeAws_restJson1ListOrdersCommand = exports.deserializeAws_restJson1ListCatalogItemsCommand = exports.deserializeAws_restJson1GetSiteAddressCommand = exports.deserializeAws_restJson1GetSiteCommand = exports.deserializeAws_restJson1GetOutpostInstanceTypesCommand = exports.deserializeAws_restJson1GetOutpostCommand = exports.deserializeAws_restJson1GetOrderCommand = exports.deserializeAws_restJson1GetCatalogItemCommand = exports.deserializeAws_restJson1DeleteSiteCommand = exports.deserializeAws_restJson1DeleteOutpostCommand = exports.deserializeAws_restJson1CreateSiteCommand = exports.deserializeAws_restJson1CreateOutpostCommand = exports.deserializeAws_restJson1CreateOrderCommand = exports.deserializeAws_restJson1CancelOrderCommand = exports.serializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand = exports.serializeAws_restJson1UpdateSiteAddressCommand = exports.serializeAws_restJson1UpdateSiteCommand = exports.serializeAws_restJson1UpdateOutpostCommand = exports.serializeAws_restJson1UntagResourceCommand = exports.serializeAws_restJson1TagResourceCommand = exports.serializeAws_restJson1ListTagsForResourceCommand = exports.serializeAws_restJson1ListSitesCommand = exports.serializeAws_restJson1ListOutpostsCommand = exports.serializeAws_restJson1ListOrdersCommand = exports.serializeAws_restJson1ListCatalogItemsCommand = exports.serializeAws_restJson1GetSiteAddressCommand = exports.serializeAws_restJson1GetSiteCommand = exports.serializeAws_restJson1GetOutpostInstanceTypesCommand = exports.serializeAws_restJson1GetOutpostCommand = exports.serializeAws_restJson1GetOrderCommand = exports.serializeAws_restJson1GetCatalogItemCommand = exports.serializeAws_restJson1DeleteSiteCommand = exports.serializeAws_restJson1DeleteOutpostCommand = exports.serializeAws_restJson1CreateSiteCommand = exports.serializeAws_restJson1CreateOutpostCommand = exports.serializeAws_restJson1CreateOrderCommand = exports.serializeAws_restJson1CancelOrderCommand = void 0;
 const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
+const serializeAws_restJson1CancelOrderCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/orders/{OrderId}/cancel";
+    if (input.OrderId !== undefined) {
+        const labelValue = input.OrderId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: OrderId.");
+        }
+        resolvedPath = resolvedPath.replace("{OrderId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: OrderId.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CancelOrderCommand = serializeAws_restJson1CancelOrderCommand;
 const serializeAws_restJson1CreateOrderCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -46,6 +72,8 @@ const serializeAws_restJson1CreateOutpostCommand = async (input, context) => {
         ...(input.Description !== undefined && input.Description !== null && { Description: input.Description }),
         ...(input.Name !== undefined && input.Name !== null && { Name: input.Name }),
         ...(input.SiteId !== undefined && input.SiteId !== null && { SiteId: input.SiteId }),
+        ...(input.SupportedHardwareType !== undefined &&
+            input.SupportedHardwareType !== null && { SupportedHardwareType: input.SupportedHardwareType }),
         ...(input.Tags !== undefined && input.Tags !== null && { Tags: serializeAws_restJson1TagMap(input.Tags, context) }),
     });
     return new protocol_http_1.HttpRequest({
@@ -59,6 +87,42 @@ const serializeAws_restJson1CreateOutpostCommand = async (input, context) => {
     });
 };
 exports.serializeAws_restJson1CreateOutpostCommand = serializeAws_restJson1CreateOutpostCommand;
+const serializeAws_restJson1CreateSiteCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/sites";
+    let body;
+    body = JSON.stringify({
+        ...(input.Description !== undefined && input.Description !== null && { Description: input.Description }),
+        ...(input.Name !== undefined && input.Name !== null && { Name: input.Name }),
+        ...(input.Notes !== undefined && input.Notes !== null && { Notes: input.Notes }),
+        ...(input.OperatingAddress !== undefined &&
+            input.OperatingAddress !== null && {
+            OperatingAddress: serializeAws_restJson1Address(input.OperatingAddress, context),
+        }),
+        ...(input.RackPhysicalProperties !== undefined &&
+            input.RackPhysicalProperties !== null && {
+            RackPhysicalProperties: serializeAws_restJson1RackPhysicalProperties(input.RackPhysicalProperties, context),
+        }),
+        ...(input.ShippingAddress !== undefined &&
+            input.ShippingAddress !== null && {
+            ShippingAddress: serializeAws_restJson1Address(input.ShippingAddress, context),
+        }),
+        ...(input.Tags !== undefined && input.Tags !== null && { Tags: serializeAws_restJson1TagMap(input.Tags, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1CreateSiteCommand = serializeAws_restJson1CreateSiteCommand;
 const serializeAws_restJson1DeleteOutpostCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -111,6 +175,58 @@ const serializeAws_restJson1DeleteSiteCommand = async (input, context) => {
     });
 };
 exports.serializeAws_restJson1DeleteSiteCommand = serializeAws_restJson1DeleteSiteCommand;
+const serializeAws_restJson1GetCatalogItemCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/catalog/item/{CatalogItemId}";
+    if (input.CatalogItemId !== undefined) {
+        const labelValue = input.CatalogItemId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: CatalogItemId.");
+        }
+        resolvedPath = resolvedPath.replace("{CatalogItemId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: CatalogItemId.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetCatalogItemCommand = serializeAws_restJson1GetCatalogItemCommand;
+const serializeAws_restJson1GetOrderCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/orders/{OrderId}";
+    if (input.OrderId !== undefined) {
+        const labelValue = input.OrderId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: OrderId.");
+        }
+        resolvedPath = resolvedPath.replace("{OrderId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: OrderId.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetOrderCommand = serializeAws_restJson1GetOrderCommand;
 const serializeAws_restJson1GetOutpostCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -168,6 +284,114 @@ const serializeAws_restJson1GetOutpostInstanceTypesCommand = async (input, conte
     });
 };
 exports.serializeAws_restJson1GetOutpostInstanceTypesCommand = serializeAws_restJson1GetOutpostInstanceTypesCommand;
+const serializeAws_restJson1GetSiteCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/sites/{SiteId}";
+    if (input.SiteId !== undefined) {
+        const labelValue = input.SiteId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: SiteId.");
+        }
+        resolvedPath = resolvedPath.replace("{SiteId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: SiteId.");
+    }
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetSiteCommand = serializeAws_restJson1GetSiteCommand;
+const serializeAws_restJson1GetSiteAddressCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/sites/{SiteId}/address";
+    if (input.SiteId !== undefined) {
+        const labelValue = input.SiteId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: SiteId.");
+        }
+        resolvedPath = resolvedPath.replace("{SiteId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: SiteId.");
+    }
+    const query = {
+        ...(input.AddressType !== undefined && { AddressType: input.AddressType }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetSiteAddressCommand = serializeAws_restJson1GetSiteAddressCommand;
+const serializeAws_restJson1ListCatalogItemsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/catalog/items";
+    const query = {
+        ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
+        ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults.toString() }),
+        ...(input.ItemClassFilter !== undefined && {
+            ItemClassFilter: (input.ItemClassFilter || []).map((_entry) => _entry),
+        }),
+        ...(input.SupportedStorageFilter !== undefined && {
+            SupportedStorageFilter: (input.SupportedStorageFilter || []).map((_entry) => _entry),
+        }),
+        ...(input.EC2FamilyFilter !== undefined && {
+            EC2FamilyFilter: (input.EC2FamilyFilter || []).map((_entry) => _entry),
+        }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListCatalogItemsCommand = serializeAws_restJson1ListCatalogItemsCommand;
+const serializeAws_restJson1ListOrdersCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/list-orders";
+    const query = {
+        ...(input.OutpostIdentifierFilter !== undefined && { OutpostIdentifierFilter: input.OutpostIdentifierFilter }),
+        ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
+        ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults.toString() }),
+    };
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListOrdersCommand = serializeAws_restJson1ListOrdersCommand;
 const serializeAws_restJson1ListOutpostsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -306,43 +530,262 @@ const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
     });
 };
 exports.serializeAws_restJson1UntagResourceCommand = serializeAws_restJson1UntagResourceCommand;
-const deserializeAws_restJson1CreateOrderCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1CreateOrderCommandError(output, context);
+const serializeAws_restJson1UpdateOutpostCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/outposts/{OutpostId}";
+    if (input.OutpostId !== undefined) {
+        const labelValue = input.OutpostId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: OutpostId.");
+        }
+        resolvedPath = resolvedPath.replace("{OutpostId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
     }
-    const contents = {
-        $metadata: deserializeMetadata(output),
-        Order: undefined,
+    else {
+        throw new Error("No value provided for input HTTP label: OutpostId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.Description !== undefined && input.Description !== null && { Description: input.Description }),
+        ...(input.Name !== undefined && input.Name !== null && { Name: input.Name }),
+        ...(input.SupportedHardwareType !== undefined &&
+            input.SupportedHardwareType !== null && { SupportedHardwareType: input.SupportedHardwareType }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateOutpostCommand = serializeAws_restJson1UpdateOutpostCommand;
+const serializeAws_restJson1UpdateSiteCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
     };
-    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.Order !== undefined && data.Order !== null) {
-        contents.Order = deserializeAws_restJson1Order(data.Order, context);
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/sites/{SiteId}";
+    if (input.SiteId !== undefined) {
+        const labelValue = input.SiteId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: SiteId.");
+        }
+        resolvedPath = resolvedPath.replace("{SiteId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
     }
-    return Promise.resolve(contents);
+    else {
+        throw new Error("No value provided for input HTTP label: SiteId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.Description !== undefined && input.Description !== null && { Description: input.Description }),
+        ...(input.Name !== undefined && input.Name !== null && { Name: input.Name }),
+        ...(input.Notes !== undefined && input.Notes !== null && { Notes: input.Notes }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
 };
-exports.deserializeAws_restJson1CreateOrderCommand = deserializeAws_restJson1CreateOrderCommand;
-const deserializeAws_restJson1CreateOrderCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseBody(output.body, context),
+exports.serializeAws_restJson1UpdateSiteCommand = serializeAws_restJson1UpdateSiteCommand;
+const serializeAws_restJson1UpdateSiteAddressCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
     };
-    let response;
-    let errorCode = "UnknownError";
-    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.outposts#AccessDeniedException":
-            response = {
-                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
-        case "ConflictException":
-        case "com.amazonaws.outposts#ConflictException":
-            response = {
-                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
-                name: errorCode,
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/sites/{SiteId}/address";
+    if (input.SiteId !== undefined) {
+        const labelValue = input.SiteId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: SiteId.");
+        }
+        resolvedPath = resolvedPath.replace("{SiteId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: SiteId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.Address !== undefined &&
+            input.Address !== null && { Address: serializeAws_restJson1Address(input.Address, context) }),
+        ...(input.AddressType !== undefined && input.AddressType !== null && { AddressType: input.AddressType }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateSiteAddressCommand = serializeAws_restJson1UpdateSiteAddressCommand;
+const serializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/sites/{SiteId}/rackPhysicalProperties";
+    if (input.SiteId !== undefined) {
+        const labelValue = input.SiteId;
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: SiteId.");
+        }
+        resolvedPath = resolvedPath.replace("{SiteId}", smithy_client_1.extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: SiteId.");
+    }
+    let body;
+    body = JSON.stringify({
+        ...(input.FiberOpticCableType !== undefined &&
+            input.FiberOpticCableType !== null && { FiberOpticCableType: input.FiberOpticCableType }),
+        ...(input.MaximumSupportedWeightLbs !== undefined &&
+            input.MaximumSupportedWeightLbs !== null && { MaximumSupportedWeightLbs: input.MaximumSupportedWeightLbs }),
+        ...(input.OpticalStandard !== undefined &&
+            input.OpticalStandard !== null && { OpticalStandard: input.OpticalStandard }),
+        ...(input.PowerConnector !== undefined &&
+            input.PowerConnector !== null && { PowerConnector: input.PowerConnector }),
+        ...(input.PowerDrawKva !== undefined && input.PowerDrawKva !== null && { PowerDrawKva: input.PowerDrawKva }),
+        ...(input.PowerFeedDrop !== undefined && input.PowerFeedDrop !== null && { PowerFeedDrop: input.PowerFeedDrop }),
+        ...(input.PowerPhase !== undefined && input.PowerPhase !== null && { PowerPhase: input.PowerPhase }),
+        ...(input.UplinkCount !== undefined && input.UplinkCount !== null && { UplinkCount: input.UplinkCount }),
+        ...(input.UplinkGbps !== undefined && input.UplinkGbps !== null && { UplinkGbps: input.UplinkGbps }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand = serializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand;
+const deserializeAws_restJson1CancelOrderCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CancelOrderCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+    };
+    await collectBody(output.body, context);
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CancelOrderCommand = deserializeAws_restJson1CancelOrderCommand;
+const deserializeAws_restJson1CancelOrderCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.outposts#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1CreateOrderCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateOrderCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Order: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Order !== undefined && data.Order !== null) {
+        contents.Order = deserializeAws_restJson1Order(data.Order, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateOrderCommand = deserializeAws_restJson1CreateOrderCommand;
+const deserializeAws_restJson1CreateOrderCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.outposts#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
                 $metadata: deserializeMetadata(output),
             };
             break;
@@ -482,6 +925,86 @@ const deserializeAws_restJson1CreateOutpostCommandError = async (output, context
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
+const deserializeAws_restJson1CreateSiteCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateSiteCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Site: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Site !== undefined && data.Site !== null) {
+        contents.Site = deserializeAws_restJson1Site(data.Site, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1CreateSiteCommand = deserializeAws_restJson1CreateSiteCommand;
+const deserializeAws_restJson1CreateSiteCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.outposts#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.outposts#ServiceQuotaExceededException":
+            response = {
+                ...(await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
 const deserializeAws_restJson1DeleteOutpostCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteOutpostCommandError(output, context);
@@ -634,22 +1157,22 @@ const deserializeAws_restJson1DeleteSiteCommandError = async (output, context) =
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1GetOutpostCommand = async (output, context) => {
+const deserializeAws_restJson1GetCatalogItemCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetOutpostCommandError(output, context);
+        return deserializeAws_restJson1GetCatalogItemCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        Outpost: undefined,
+        CatalogItem: undefined,
     };
     const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.Outpost !== undefined && data.Outpost !== null) {
-        contents.Outpost = deserializeAws_restJson1Outpost(data.Outpost, context);
+    if (data.CatalogItem !== undefined && data.CatalogItem !== null) {
+        contents.CatalogItem = deserializeAws_restJson1CatalogItem(data.CatalogItem, context);
     }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1GetOutpostCommand = deserializeAws_restJson1GetOutpostCommand;
-const deserializeAws_restJson1GetOutpostCommandError = async (output, context) => {
+exports.deserializeAws_restJson1GetCatalogItemCommand = deserializeAws_restJson1GetCatalogItemCommand;
+const deserializeAws_restJson1GetCatalogItemCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -658,14 +1181,722 @@ const deserializeAws_restJson1GetOutpostCommandError = async (output, context) =
     let errorCode = "UnknownError";
     errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.outposts#AccessDeniedException":
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
             response = {
-                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
                 name: errorCode,
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetOrderCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetOrderCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Order: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Order !== undefined && data.Order !== null) {
+        contents.Order = deserializeAws_restJson1Order(data.Order, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetOrderCommand = deserializeAws_restJson1GetOrderCommand;
+const deserializeAws_restJson1GetOrderCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetOutpostCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetOutpostCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Outpost: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Outpost !== undefined && data.Outpost !== null) {
+        contents.Outpost = deserializeAws_restJson1Outpost(data.Outpost, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetOutpostCommand = deserializeAws_restJson1GetOutpostCommand;
+const deserializeAws_restJson1GetOutpostCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetOutpostInstanceTypesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetOutpostInstanceTypesCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        InstanceTypes: undefined,
+        NextToken: undefined,
+        OutpostArn: undefined,
+        OutpostId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.InstanceTypes !== undefined && data.InstanceTypes !== null) {
+        contents.InstanceTypes = deserializeAws_restJson1InstanceTypeListDefinition(data.InstanceTypes, context);
+    }
+    if (data.NextToken !== undefined && data.NextToken !== null) {
+        contents.NextToken = smithy_client_1.expectString(data.NextToken);
+    }
+    if (data.OutpostArn !== undefined && data.OutpostArn !== null) {
+        contents.OutpostArn = smithy_client_1.expectString(data.OutpostArn);
+    }
+    if (data.OutpostId !== undefined && data.OutpostId !== null) {
+        contents.OutpostId = smithy_client_1.expectString(data.OutpostId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetOutpostInstanceTypesCommand = deserializeAws_restJson1GetOutpostInstanceTypesCommand;
+const deserializeAws_restJson1GetOutpostInstanceTypesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetSiteCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetSiteCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Site: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Site !== undefined && data.Site !== null) {
+        contents.Site = deserializeAws_restJson1Site(data.Site, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetSiteCommand = deserializeAws_restJson1GetSiteCommand;
+const deserializeAws_restJson1GetSiteCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1GetSiteAddressCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetSiteAddressCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Address: undefined,
+        AddressType: undefined,
+        SiteId: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Address !== undefined && data.Address !== null) {
+        contents.Address = deserializeAws_restJson1Address(data.Address, context);
+    }
+    if (data.AddressType !== undefined && data.AddressType !== null) {
+        contents.AddressType = smithy_client_1.expectString(data.AddressType);
+    }
+    if (data.SiteId !== undefined && data.SiteId !== null) {
+        contents.SiteId = smithy_client_1.expectString(data.SiteId);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1GetSiteAddressCommand = deserializeAws_restJson1GetSiteAddressCommand;
+const deserializeAws_restJson1GetSiteAddressCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListCatalogItemsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListCatalogItemsCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        CatalogItems: undefined,
+        NextToken: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.CatalogItems !== undefined && data.CatalogItems !== null) {
+        contents.CatalogItems = deserializeAws_restJson1CatalogItemListDefinition(data.CatalogItems, context);
+    }
+    if (data.NextToken !== undefined && data.NextToken !== null) {
+        contents.NextToken = smithy_client_1.expectString(data.NextToken);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListCatalogItemsCommand = deserializeAws_restJson1ListCatalogItemsCommand;
+const deserializeAws_restJson1ListCatalogItemsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListOrdersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListOrdersCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        NextToken: undefined,
+        Orders: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.NextToken !== undefined && data.NextToken !== null) {
+        contents.NextToken = smithy_client_1.expectString(data.NextToken);
+    }
+    if (data.Orders !== undefined && data.Orders !== null) {
+        contents.Orders = deserializeAws_restJson1OrderSummaryListDefinition(data.Orders, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListOrdersCommand = deserializeAws_restJson1ListOrdersCommand;
+const deserializeAws_restJson1ListOrdersCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListOutpostsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListOutpostsCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        NextToken: undefined,
+        Outposts: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.NextToken !== undefined && data.NextToken !== null) {
+        contents.NextToken = smithy_client_1.expectString(data.NextToken);
+    }
+    if (data.Outposts !== undefined && data.Outposts !== null) {
+        contents.Outposts = deserializeAws_restJson1outpostListDefinition(data.Outposts, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListOutpostsCommand = deserializeAws_restJson1ListOutpostsCommand;
+const deserializeAws_restJson1ListOutpostsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListSitesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListSitesCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        NextToken: undefined,
+        Sites: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.NextToken !== undefined && data.NextToken !== null) {
+        contents.NextToken = smithy_client_1.expectString(data.NextToken);
+    }
+    if (data.Sites !== undefined && data.Sites !== null) {
+        contents.Sites = deserializeAws_restJson1siteListDefinition(data.Sites, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListSitesCommand = deserializeAws_restJson1ListSitesCommand;
+const deserializeAws_restJson1ListSitesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
+            response = {
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ValidationException":
+        case "com.amazonaws.outposts#ValidationException":
+            response = {
+                ...(await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        default:
+            const parsedBody = parsedOutput.body;
+            errorCode = parsedBody.code || parsedBody.Code || errorCode;
+            response = {
+                ...parsedBody,
+                name: `${errorCode}`,
+                message: parsedBody.message || parsedBody.Message || errorCode,
+                $fault: "client",
+                $metadata: deserializeMetadata(output),
+            };
+    }
+    const message = response.message || response.Message || errorCode;
+    response.message = message;
+    delete response.Message;
+    return Promise.reject(Object.assign(new Error(message), response));
+};
+const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+    }
+    const contents = {
+        $metadata: deserializeMetadata(output),
+        Tags: undefined,
+    };
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Tags !== undefined && data.Tags !== null) {
+        contents.Tags = deserializeAws_restJson1TagMap(data.Tags, context);
+    }
+    return Promise.resolve(contents);
+};
+exports.deserializeAws_restJson1ListTagsForResourceCommand = deserializeAws_restJson1ListTagsForResourceCommand;
+const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    let response;
+    let errorCode = "UnknownError";
+    errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
         case "InternalServerException":
         case "com.amazonaws.outposts#InternalServerException":
             response = {
@@ -706,34 +1937,18 @@ const deserializeAws_restJson1GetOutpostCommandError = async (output, context) =
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1GetOutpostInstanceTypesCommand = async (output, context) => {
+const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetOutpostInstanceTypesCommandError(output, context);
+        return deserializeAws_restJson1TagResourceCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        InstanceTypes: undefined,
-        NextToken: undefined,
-        OutpostArn: undefined,
-        OutpostId: undefined,
     };
-    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.InstanceTypes !== undefined && data.InstanceTypes !== null) {
-        contents.InstanceTypes = deserializeAws_restJson1InstanceTypeListDefinition(data.InstanceTypes, context);
-    }
-    if (data.NextToken !== undefined && data.NextToken !== null) {
-        contents.NextToken = smithy_client_1.expectString(data.NextToken);
-    }
-    if (data.OutpostArn !== undefined && data.OutpostArn !== null) {
-        contents.OutpostArn = smithy_client_1.expectString(data.OutpostArn);
-    }
-    if (data.OutpostId !== undefined && data.OutpostId !== null) {
-        contents.OutpostId = smithy_client_1.expectString(data.OutpostId);
-    }
+    await collectBody(output.body, context);
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1GetOutpostInstanceTypesCommand = deserializeAws_restJson1GetOutpostInstanceTypesCommand;
-const deserializeAws_restJson1GetOutpostInstanceTypesCommandError = async (output, context) => {
+exports.deserializeAws_restJson1TagResourceCommand = deserializeAws_restJson1TagResourceCommand;
+const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -742,14 +1957,6 @@ const deserializeAws_restJson1GetOutpostInstanceTypesCommandError = async (outpu
     let errorCode = "UnknownError";
     errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.outposts#AccessDeniedException":
-            response = {
-                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
-                name: errorCode,
-                $metadata: deserializeMetadata(output),
-            };
-            break;
         case "InternalServerException":
         case "com.amazonaws.outposts#InternalServerException":
             response = {
@@ -790,26 +1997,18 @@ const deserializeAws_restJson1GetOutpostInstanceTypesCommandError = async (outpu
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1ListOutpostsCommand = async (output, context) => {
+const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListOutpostsCommandError(output, context);
+        return deserializeAws_restJson1UntagResourceCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        NextToken: undefined,
-        Outposts: undefined,
     };
-    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.NextToken !== undefined && data.NextToken !== null) {
-        contents.NextToken = smithy_client_1.expectString(data.NextToken);
-    }
-    if (data.Outposts !== undefined && data.Outposts !== null) {
-        contents.Outposts = deserializeAws_restJson1outpostListDefinition(data.Outposts, context);
-    }
+    await collectBody(output.body, context);
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1ListOutpostsCommand = deserializeAws_restJson1ListOutpostsCommand;
-const deserializeAws_restJson1ListOutpostsCommandError = async (output, context) => {
+exports.deserializeAws_restJson1UntagResourceCommand = deserializeAws_restJson1UntagResourceCommand;
+const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -818,18 +2017,18 @@ const deserializeAws_restJson1ListOutpostsCommandError = async (output, context)
     let errorCode = "UnknownError";
     errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.outposts#AccessDeniedException":
+        case "InternalServerException":
+        case "com.amazonaws.outposts#InternalServerException":
             response = {
-                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
                 name: errorCode,
                 $metadata: deserializeMetadata(output),
             };
             break;
-        case "InternalServerException":
-        case "com.amazonaws.outposts#InternalServerException":
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
             response = {
-                ...(await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context)),
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
                 name: errorCode,
                 $metadata: deserializeMetadata(output),
             };
@@ -858,26 +2057,22 @@ const deserializeAws_restJson1ListOutpostsCommandError = async (output, context)
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1ListSitesCommand = async (output, context) => {
+const deserializeAws_restJson1UpdateOutpostCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListSitesCommandError(output, context);
+        return deserializeAws_restJson1UpdateOutpostCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        NextToken: undefined,
-        Sites: undefined,
+        Outpost: undefined,
     };
     const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.NextToken !== undefined && data.NextToken !== null) {
-        contents.NextToken = smithy_client_1.expectString(data.NextToken);
-    }
-    if (data.Sites !== undefined && data.Sites !== null) {
-        contents.Sites = deserializeAws_restJson1siteListDefinition(data.Sites, context);
+    if (data.Outpost !== undefined && data.Outpost !== null) {
+        contents.Outpost = deserializeAws_restJson1Outpost(data.Outpost, context);
     }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1ListSitesCommand = deserializeAws_restJson1ListSitesCommand;
-const deserializeAws_restJson1ListSitesCommandError = async (output, context) => {
+exports.deserializeAws_restJson1UpdateOutpostCommand = deserializeAws_restJson1UpdateOutpostCommand;
+const deserializeAws_restJson1UpdateOutpostCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -894,6 +2089,14 @@ const deserializeAws_restJson1ListSitesCommandError = async (output, context) =>
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "ConflictException":
+        case "com.amazonaws.outposts#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "InternalServerException":
         case "com.amazonaws.outposts#InternalServerException":
             response = {
@@ -902,6 +2105,14 @@ const deserializeAws_restJson1ListSitesCommandError = async (output, context) =>
                 $metadata: deserializeMetadata(output),
             };
             break;
+        case "NotFoundException":
+        case "com.amazonaws.outposts#NotFoundException":
+            response = {
+                ...(await deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "ValidationException":
         case "com.amazonaws.outposts#ValidationException":
             response = {
@@ -926,22 +2137,22 @@ const deserializeAws_restJson1ListSitesCommandError = async (output, context) =>
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+const deserializeAws_restJson1UpdateSiteCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+        return deserializeAws_restJson1UpdateSiteCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
-        Tags: undefined,
+        Site: undefined,
     };
     const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
-    if (data.Tags !== undefined && data.Tags !== null) {
-        contents.Tags = deserializeAws_restJson1TagMap(data.Tags, context);
+    if (data.Site !== undefined && data.Site !== null) {
+        contents.Site = deserializeAws_restJson1Site(data.Site, context);
     }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1ListTagsForResourceCommand = deserializeAws_restJson1ListTagsForResourceCommand;
-const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+exports.deserializeAws_restJson1UpdateSiteCommand = deserializeAws_restJson1UpdateSiteCommand;
+const deserializeAws_restJson1UpdateSiteCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -950,6 +2161,22 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
     let errorCode = "UnknownError";
     errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.outposts#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "InternalServerException":
         case "com.amazonaws.outposts#InternalServerException":
             response = {
@@ -990,18 +2217,26 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+const deserializeAws_restJson1UpdateSiteAddressCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1TagResourceCommandError(output, context);
+        return deserializeAws_restJson1UpdateSiteAddressCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
+        Address: undefined,
+        AddressType: undefined,
     };
-    await collectBody(output.body, context);
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Address !== undefined && data.Address !== null) {
+        contents.Address = deserializeAws_restJson1Address(data.Address, context);
+    }
+    if (data.AddressType !== undefined && data.AddressType !== null) {
+        contents.AddressType = smithy_client_1.expectString(data.AddressType);
+    }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1TagResourceCommand = deserializeAws_restJson1TagResourceCommand;
-const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+exports.deserializeAws_restJson1UpdateSiteAddressCommand = deserializeAws_restJson1UpdateSiteAddressCommand;
+const deserializeAws_restJson1UpdateSiteAddressCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -1010,6 +2245,22 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
     let errorCode = "UnknownError";
     errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.outposts#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "InternalServerException":
         case "com.amazonaws.outposts#InternalServerException":
             response = {
@@ -1050,18 +2301,22 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
     delete response.Message;
     return Promise.reject(Object.assign(new Error(message), response));
 };
-const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+const deserializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+        return deserializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommandError(output, context);
     }
     const contents = {
         $metadata: deserializeMetadata(output),
+        Site: undefined,
     };
-    await collectBody(output.body, context);
+    const data = smithy_client_1.expectNonNull(smithy_client_1.expectObject(await parseBody(output.body, context)), "body");
+    if (data.Site !== undefined && data.Site !== null) {
+        contents.Site = deserializeAws_restJson1Site(data.Site, context);
+    }
     return Promise.resolve(contents);
 };
-exports.deserializeAws_restJson1UntagResourceCommand = deserializeAws_restJson1UntagResourceCommand;
-const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+exports.deserializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand = deserializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommand;
+const deserializeAws_restJson1UpdateSiteRackPhysicalPropertiesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
@@ -1070,6 +2325,22 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
     let errorCode = "UnknownError";
     errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.outposts#AccessDeniedException":
+            response = {
+                ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
+        case "ConflictException":
+        case "com.amazonaws.outposts#ConflictException":
+            response = {
+                ...(await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "InternalServerException":
         case "com.amazonaws.outposts#InternalServerException":
             response = {
@@ -1196,6 +2467,23 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     }
     return contents;
 };
+const serializeAws_restJson1Address = (input, context) => {
+    return {
+        ...(input.AddressLine1 !== undefined && input.AddressLine1 !== null && { AddressLine1: input.AddressLine1 }),
+        ...(input.AddressLine2 !== undefined && input.AddressLine2 !== null && { AddressLine2: input.AddressLine2 }),
+        ...(input.AddressLine3 !== undefined && input.AddressLine3 !== null && { AddressLine3: input.AddressLine3 }),
+        ...(input.City !== undefined && input.City !== null && { City: input.City }),
+        ...(input.ContactName !== undefined && input.ContactName !== null && { ContactName: input.ContactName }),
+        ...(input.ContactPhoneNumber !== undefined &&
+            input.ContactPhoneNumber !== null && { ContactPhoneNumber: input.ContactPhoneNumber }),
+        ...(input.CountryCode !== undefined && input.CountryCode !== null && { CountryCode: input.CountryCode }),
+        ...(input.DistrictOrCounty !== undefined &&
+            input.DistrictOrCounty !== null && { DistrictOrCounty: input.DistrictOrCounty }),
+        ...(input.Municipality !== undefined && input.Municipality !== null && { Municipality: input.Municipality }),
+        ...(input.PostalCode !== undefined && input.PostalCode !== null && { PostalCode: input.PostalCode }),
+        ...(input.StateOrRegion !== undefined && input.StateOrRegion !== null && { StateOrRegion: input.StateOrRegion }),
+    };
+};
 const serializeAws_restJson1LineItemRequest = (input, context) => {
     return {
         ...(input.CatalogItemId !== undefined && input.CatalogItemId !== null && { CatalogItemId: input.CatalogItemId }),
@@ -1212,6 +2500,23 @@ const serializeAws_restJson1LineItemRequestListDefinition = (input, context) =>
         return serializeAws_restJson1LineItemRequest(entry, context);
     });
 };
+const serializeAws_restJson1RackPhysicalProperties = (input, context) => {
+    return {
+        ...(input.FiberOpticCableType !== undefined &&
+            input.FiberOpticCableType !== null && { FiberOpticCableType: input.FiberOpticCableType }),
+        ...(input.MaximumSupportedWeightLbs !== undefined &&
+            input.MaximumSupportedWeightLbs !== null && { MaximumSupportedWeightLbs: input.MaximumSupportedWeightLbs }),
+        ...(input.OpticalStandard !== undefined &&
+            input.OpticalStandard !== null && { OpticalStandard: input.OpticalStandard }),
+        ...(input.PowerConnector !== undefined &&
+            input.PowerConnector !== null && { PowerConnector: input.PowerConnector }),
+        ...(input.PowerDrawKva !== undefined && input.PowerDrawKva !== null && { PowerDrawKva: input.PowerDrawKva }),
+        ...(input.PowerFeedDrop !== undefined && input.PowerFeedDrop !== null && { PowerFeedDrop: input.PowerFeedDrop }),
+        ...(input.PowerPhase !== undefined && input.PowerPhase !== null && { PowerPhase: input.PowerPhase }),
+        ...(input.UplinkCount !== undefined && input.UplinkCount !== null && { UplinkCount: input.UplinkCount }),
+        ...(input.UplinkGbps !== undefined && input.UplinkGbps !== null && { UplinkGbps: input.UplinkGbps }),
+    };
+};
 const serializeAws_restJson1TagMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
@@ -1223,6 +2528,65 @@ const serializeAws_restJson1TagMap = (input, context) => {
         };
     }, {});
 };
+const deserializeAws_restJson1Address = (output, context) => {
+    return {
+        AddressLine1: smithy_client_1.expectString(output.AddressLine1),
+        AddressLine2: smithy_client_1.expectString(output.AddressLine2),
+        AddressLine3: smithy_client_1.expectString(output.AddressLine3),
+        City: smithy_client_1.expectString(output.City),
+        ContactName: smithy_client_1.expectString(output.ContactName),
+        ContactPhoneNumber: smithy_client_1.expectString(output.ContactPhoneNumber),
+        CountryCode: smithy_client_1.expectString(output.CountryCode),
+        DistrictOrCounty: smithy_client_1.expectString(output.DistrictOrCounty),
+        Municipality: smithy_client_1.expectString(output.Municipality),
+        PostalCode: smithy_client_1.expectString(output.PostalCode),
+        StateOrRegion: smithy_client_1.expectString(output.StateOrRegion),
+    };
+};
+const deserializeAws_restJson1CatalogItem = (output, context) => {
+    return {
+        CatalogItemId: smithy_client_1.expectString(output.CatalogItemId),
+        EC2Capacities: output.EC2Capacities !== undefined && output.EC2Capacities !== null
+            ? deserializeAws_restJson1EC2CapacityListDefinition(output.EC2Capacities, context)
+            : undefined,
+        ItemStatus: smithy_client_1.expectString(output.ItemStatus),
+        PowerKva: smithy_client_1.limitedParseFloat32(output.PowerKva),
+        SupportedStorage: output.SupportedStorage !== undefined && output.SupportedStorage !== null
+            ? deserializeAws_restJson1SupportedStorageList(output.SupportedStorage, context)
+            : undefined,
+        SupportedUplinkGbps: output.SupportedUplinkGbps !== undefined && output.SupportedUplinkGbps !== null
+            ? deserializeAws_restJson1SupportedUplinkGbpsListDefinition(output.SupportedUplinkGbps, context)
+            : undefined,
+        WeightLbs: smithy_client_1.expectInt32(output.WeightLbs),
+    };
+};
+const deserializeAws_restJson1CatalogItemListDefinition = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1CatalogItem(entry, context);
+    });
+};
+const deserializeAws_restJson1EC2Capacity = (output, context) => {
+    return {
+        Family: smithy_client_1.expectString(output.Family),
+        MaxSize: smithy_client_1.expectString(output.MaxSize),
+        Quantity: smithy_client_1.expectString(output.Quantity),
+    };
+};
+const deserializeAws_restJson1EC2CapacityListDefinition = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EC2Capacity(entry, context);
+    });
+};
 const deserializeAws_restJson1InstanceTypeItem = (output, context) => {
     return {
         InstanceType: smithy_client_1.expectString(output.InstanceType),
@@ -1256,6 +2620,17 @@ const deserializeAws_restJson1LineItemListDefinition = (output, context) => {
         return deserializeAws_restJson1LineItem(entry, context);
     });
 };
+const deserializeAws_restJson1LineItemStatusCounts = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: smithy_client_1.expectInt32(value),
+        };
+    }, {});
+};
 const deserializeAws_restJson1Order = (output, context) => {
     return {
         LineItems: output.LineItems !== undefined && output.LineItems !== null
@@ -1273,6 +2648,33 @@ const deserializeAws_restJson1Order = (output, context) => {
         Status: smithy_client_1.expectString(output.Status),
     };
 };
+const deserializeAws_restJson1OrderSummary = (output, context) => {
+    return {
+        LineItemCountsByStatus: output.LineItemCountsByStatus !== undefined && output.LineItemCountsByStatus !== null
+            ? deserializeAws_restJson1LineItemStatusCounts(output.LineItemCountsByStatus, context)
+            : undefined,
+        OrderFulfilledDate: output.OrderFulfilledDate !== undefined && output.OrderFulfilledDate !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.OrderFulfilledDate)))
+            : undefined,
+        OrderId: smithy_client_1.expectString(output.OrderId),
+        OrderSubmissionDate: output.OrderSubmissionDate !== undefined && output.OrderSubmissionDate !== null
+            ? smithy_client_1.expectNonNull(smithy_client_1.parseEpochTimestamp(smithy_client_1.expectNumber(output.OrderSubmissionDate)))
+            : undefined,
+        OrderType: smithy_client_1.expectString(output.OrderType),
+        OutpostId: smithy_client_1.expectString(output.OutpostId),
+        Status: smithy_client_1.expectString(output.Status),
+    };
+};
+const deserializeAws_restJson1OrderSummaryListDefinition = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1OrderSummary(entry, context);
+    });
+};
 const deserializeAws_restJson1Outpost = (output, context) => {
     return {
         AvailabilityZone: smithy_client_1.expectString(output.AvailabilityZone),
@@ -1285,6 +2687,7 @@ const deserializeAws_restJson1Outpost = (output, context) => {
         OwnerId: smithy_client_1.expectString(output.OwnerId),
         SiteArn: smithy_client_1.expectString(output.SiteArn),
         SiteId: smithy_client_1.expectString(output.SiteId),
+        SupportedHardwareType: smithy_client_1.expectString(output.SupportedHardwareType),
         Tags: output.Tags !== undefined && output.Tags !== null
             ? deserializeAws_restJson1TagMap(output.Tags, context)
             : undefined,
@@ -1300,11 +2703,31 @@ const deserializeAws_restJson1outpostListDefinition = (output, context) => {
         return deserializeAws_restJson1Outpost(entry, context);
     });
 };
+const deserializeAws_restJson1RackPhysicalProperties = (output, context) => {
+    return {
+        FiberOpticCableType: smithy_client_1.expectString(output.FiberOpticCableType),
+        MaximumSupportedWeightLbs: smithy_client_1.expectString(output.MaximumSupportedWeightLbs),
+        OpticalStandard: smithy_client_1.expectString(output.OpticalStandard),
+        PowerConnector: smithy_client_1.expectString(output.PowerConnector),
+        PowerDrawKva: smithy_client_1.expectString(output.PowerDrawKva),
+        PowerFeedDrop: smithy_client_1.expectString(output.PowerFeedDrop),
+        PowerPhase: smithy_client_1.expectString(output.PowerPhase),
+        UplinkCount: smithy_client_1.expectString(output.UplinkCount),
+        UplinkGbps: smithy_client_1.expectString(output.UplinkGbps),
+    };
+};
 const deserializeAws_restJson1Site = (output, context) => {
     return {
         AccountId: smithy_client_1.expectString(output.AccountId),
         Description: smithy_client_1.expectString(output.Description),
         Name: smithy_client_1.expectString(output.Name),
+        Notes: smithy_client_1.expectString(output.Notes),
+        OperatingAddressCity: smithy_client_1.expectString(output.OperatingAddressCity),
+        OperatingAddressCountryCode: smithy_client_1.expectString(output.OperatingAddressCountryCode),
+        OperatingAddressStateOrRegion: smithy_client_1.expectString(output.OperatingAddressStateOrRegion),
+        RackPhysicalProperties: output.RackPhysicalProperties !== undefined && output.RackPhysicalProperties !== null
+            ? deserializeAws_restJson1RackPhysicalProperties(output.RackPhysicalProperties, context)
+            : undefined,
         SiteArn: smithy_client_1.expectString(output.SiteArn),
         SiteId: smithy_client_1.expectString(output.SiteId),
         Tags: output.Tags !== undefined && output.Tags !== null
@@ -1322,6 +2745,26 @@ const deserializeAws_restJson1siteListDefinition = (output, context) => {
         return deserializeAws_restJson1Site(entry, context);
     });
 };
+const deserializeAws_restJson1SupportedStorageList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_restJson1SupportedUplinkGbpsListDefinition = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectInt32(entry);
+    });
+};
 const deserializeAws_restJson1TagMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {