@aws-sdk/client-location 3.476.0 → 3.478.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -3,18 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.se_SearchPlaceIndexForTextCommand = exports.se_SearchPlaceIndexForSuggestionsCommand = exports.se_SearchPlaceIndexForPositionCommand = exports.se_PutGeofenceCommand = exports.se_ListTrackersCommand = exports.se_ListTrackerConsumersCommand = exports.se_ListTagsForResourceCommand = exports.se_ListRouteCalculatorsCommand = exports.se_ListPlaceIndexesCommand = exports.se_ListMapsCommand = exports.se_ListKeysCommand = exports.se_ListGeofencesCommand = exports.se_ListGeofenceCollectionsCommand = exports.se_ListDevicePositionsCommand = exports.se_GetPlaceCommand = exports.se_GetMapTileCommand = exports.se_GetMapStyleDescriptorCommand = exports.se_GetMapSpritesCommand = exports.se_GetMapGlyphsCommand = exports.se_GetGeofenceCommand = exports.se_GetDevicePositionHistoryCommand = exports.se_GetDevicePositionCommand = exports.se_DisassociateTrackerConsumerCommand = exports.se_DescribeTrackerCommand = exports.se_DescribeRouteCalculatorCommand = exports.se_DescribePlaceIndexCommand = exports.se_DescribeMapCommand = exports.se_DescribeKeyCommand = exports.se_DescribeGeofenceCollectionCommand = exports.se_DeleteTrackerCommand = exports.se_DeleteRouteCalculatorCommand = exports.se_DeletePlaceIndexCommand = exports.se_DeleteMapCommand = exports.se_DeleteKeyCommand = exports.se_DeleteGeofenceCollectionCommand = exports.se_CreateTrackerCommand = exports.se_CreateRouteCalculatorCommand = exports.se_CreatePlaceIndexCommand = exports.se_CreateMapCommand = exports.se_CreateKeyCommand = exports.se_CreateGeofenceCollectionCommand = exports.se_CalculateRouteMatrixCommand = exports.se_CalculateRouteCommand = exports.se_BatchUpdateDevicePositionCommand = exports.se_BatchPutGeofenceCommand = exports.se_BatchGetDevicePositionCommand = exports.se_BatchEvaluateGeofencesCommand = exports.se_BatchDeleteGeofenceCommand = exports.se_BatchDeleteDevicePositionHistoryCommand = exports.se_AssociateTrackerConsumerCommand = void 0;
 exports.de_ListPlaceIndexesCommand = exports.de_ListMapsCommand = exports.de_ListKeysCommand = exports.de_ListGeofencesCommand = exports.de_ListGeofenceCollectionsCommand = exports.de_ListDevicePositionsCommand = exports.de_GetPlaceCommand = exports.de_GetMapTileCommand = exports.de_GetMapStyleDescriptorCommand = exports.de_GetMapSpritesCommand = exports.de_GetMapGlyphsCommand = exports.de_GetGeofenceCommand = exports.de_GetDevicePositionHistoryCommand = exports.de_GetDevicePositionCommand = exports.de_DisassociateTrackerConsumerCommand = exports.de_DescribeTrackerCommand = exports.de_DescribeRouteCalculatorCommand = exports.de_DescribePlaceIndexCommand = exports.de_DescribeMapCommand = exports.de_DescribeKeyCommand = exports.de_DescribeGeofenceCollectionCommand = exports.de_DeleteTrackerCommand = exports.de_DeleteRouteCalculatorCommand = exports.de_DeletePlaceIndexCommand = exports.de_DeleteMapCommand = exports.de_DeleteKeyCommand = exports.de_DeleteGeofenceCollectionCommand = exports.de_CreateTrackerCommand = exports.de_CreateRouteCalculatorCommand = exports.de_CreatePlaceIndexCommand = exports.de_CreateMapCommand = exports.de_CreateKeyCommand = exports.de_CreateGeofenceCollectionCommand = exports.de_CalculateRouteMatrixCommand = exports.de_CalculateRouteCommand = exports.de_BatchUpdateDevicePositionCommand = exports.de_BatchPutGeofenceCommand = exports.de_BatchGetDevicePositionCommand = exports.de_BatchEvaluateGeofencesCommand = exports.de_BatchDeleteGeofenceCommand = exports.de_BatchDeleteDevicePositionHistoryCommand = exports.de_AssociateTrackerConsumerCommand = exports.se_UpdateTrackerCommand = exports.se_UpdateRouteCalculatorCommand = exports.se_UpdatePlaceIndexCommand = exports.se_UpdateMapCommand = exports.se_UpdateKeyCommand = exports.se_UpdateGeofenceCollectionCommand = exports.se_UntagResourceCommand = exports.se_TagResourceCommand = void 0;
 exports.de_UpdateTrackerCommand = exports.de_UpdateRouteCalculatorCommand = exports.de_UpdatePlaceIndexCommand = exports.de_UpdateMapCommand = exports.de_UpdateKeyCommand = exports.de_UpdateGeofenceCollectionCommand = exports.de_UntagResourceCommand = exports.de_TagResourceCommand = exports.de_SearchPlaceIndexForTextCommand = exports.de_SearchPlaceIndexForSuggestionsCommand = exports.de_SearchPlaceIndexForPositionCommand = exports.de_PutGeofenceCommand = exports.de_ListTrackersCommand = exports.de_ListTrackerConsumersCommand = exports.de_ListTagsForResourceCommand = exports.de_ListRouteCalculatorsCommand = void 0;
+const core_1 = require("@smithy/core");
 const protocol_http_1 = require("@smithy/protocol-http");
 const smithy_client_1 = require("@smithy/smithy-client");
 const LocationServiceException_1 = require("../models/LocationServiceException");
 const models_0_1 = require("../models/models_0");
 const se_AssociateTrackerConsumerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/consumers";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/consumers");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         ConsumerArn: [],
@@ -26,25 +26,18 @@ const se_AssociateTrackerConsumerCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_AssociateTrackerConsumerCommand = se_AssociateTrackerConsumerCommand;
 const se_BatchDeleteDevicePositionHistoryCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/delete-positions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/delete-positions");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         DeviceIds: (_) => (0, smithy_client_1._json)(_),
@@ -56,25 +49,18 @@ const se_BatchDeleteDevicePositionHistoryCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_BatchDeleteDevicePositionHistoryCommand = se_BatchDeleteDevicePositionHistoryCommand;
 const se_BatchDeleteGeofenceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}/delete-geofences";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}/delete-geofences");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         GeofenceIds: (_) => (0, smithy_client_1._json)(_),
@@ -86,25 +72,18 @@ const se_BatchDeleteGeofenceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_BatchDeleteGeofenceCommand = se_BatchDeleteGeofenceCommand;
 const se_BatchEvaluateGeofencesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}/positions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}/positions");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         DevicePositionUpdates: (_) => se_DevicePositionUpdateList(_, context),
@@ -116,25 +95,18 @@ const se_BatchEvaluateGeofencesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_BatchEvaluateGeofencesCommand = se_BatchEvaluateGeofencesCommand;
 const se_BatchGetDevicePositionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/get-positions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/get-positions");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         DeviceIds: (_) => (0, smithy_client_1._json)(_),
@@ -146,25 +118,18 @@ const se_BatchGetDevicePositionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_BatchGetDevicePositionCommand = se_BatchGetDevicePositionCommand;
 const se_BatchPutGeofenceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}/put-geofences";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}/put-geofences");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Entries: (_) => se_BatchPutGeofenceRequestEntryList(_, context),
@@ -176,25 +141,18 @@ const se_BatchPutGeofenceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_BatchPutGeofenceCommand = se_BatchPutGeofenceCommand;
 const se_BatchUpdateDevicePositionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/positions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/positions");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Updates: (_) => se_DevicePositionUpdateList(_, context),
@@ -206,27 +164,20 @@ const se_BatchUpdateDevicePositionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_BatchUpdateDevicePositionCommand = se_BatchUpdateDevicePositionCommand;
 const se_CalculateRouteCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/routes/v0/calculators/{CalculatorName}/calculate/route";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
+    b.bp("/routes/v0/calculators/{CalculatorName}/calculate/route");
+    b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -250,28 +201,20 @@ const se_CalculateRouteCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_CalculateRouteCommand = se_CalculateRouteCommand;
 const se_CalculateRouteMatrixCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/routes/v0/calculators/{CalculatorName}/calculate/route-matrix";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
+    b.bp("/routes/v0/calculators/{CalculatorName}/calculate/route-matrix");
+    b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -291,24 +234,17 @@ const se_CalculateRouteMatrixCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_CalculateRouteMatrixCommand = se_CalculateRouteMatrixCommand;
 const se_CreateGeofenceCollectionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/geofencing/v0/collections";
+    b.bp("/geofencing/v0/collections");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         CollectionName: [],
@@ -325,23 +261,17 @@ const se_CreateGeofenceCollectionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateGeofenceCollectionCommand = se_CreateGeofenceCollectionCommand;
 const se_CreateKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata/v0/keys";
+    b.bp("/metadata/v0/keys");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Description: [],
@@ -358,23 +288,17 @@ const se_CreateKeyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateKeyCommand = se_CreateKeyCommand;
 const se_CreateMapCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/maps";
+    b.bp("/maps/v0/maps");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Configuration: (_) => (0, smithy_client_1._json)(_),
@@ -390,23 +314,17 @@ const se_CreateMapCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateMapCommand = se_CreateMapCommand;
 const se_CreatePlaceIndexCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/places/v0/indexes";
+    b.bp("/places/v0/indexes");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         DataSource: [],
@@ -423,23 +341,17 @@ const se_CreatePlaceIndexCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreatePlaceIndexCommand = se_CreatePlaceIndexCommand;
 const se_CreateRouteCalculatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/routes/v0/calculators";
+    b.bp("/routes/v0/calculators");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         CalculatorName: [],
@@ -455,23 +367,17 @@ const se_CreateRouteCalculatorCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateRouteCalculatorCommand = se_CreateRouteCalculatorCommand;
 const se_CreateTrackerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tracking/v0/trackers";
+    b.bp("/tracking/v0/trackers");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Description: [],
@@ -491,23 +397,16 @@ const se_CreateTrackerCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateTrackerCommand = se_CreateTrackerCommand;
 const se_DeleteGeofenceCollectionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -516,22 +415,16 @@ const se_DeleteGeofenceCollectionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteGeofenceCollectionCommand = se_DeleteGeofenceCollectionCommand;
 const se_DeleteKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata/v0/keys/{KeyName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "KeyName", () => input.KeyName, "{KeyName}", false);
+    b.bp("/metadata/v0/keys/{KeyName}");
+    b.p("KeyName", () => input.KeyName, "{KeyName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -540,22 +433,16 @@ const se_DeleteKeyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteKeyCommand = se_DeleteKeyCommand;
 const se_DeleteMapCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/maps/{MapName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
+    b.bp("/maps/v0/maps/{MapName}");
+    b.p("MapName", () => input.MapName, "{MapName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -564,22 +451,16 @@ const se_DeleteMapCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteMapCommand = se_DeleteMapCommand;
 const se_DeletePlaceIndexCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/places/v0/indexes/{IndexName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
+    b.bp("/places/v0/indexes/{IndexName}");
+    b.p("IndexName", () => input.IndexName, "{IndexName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -588,22 +469,16 @@ const se_DeletePlaceIndexCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeletePlaceIndexCommand = se_DeletePlaceIndexCommand;
 const se_DeleteRouteCalculatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/routes/v0/calculators/{CalculatorName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
+    b.bp("/routes/v0/calculators/{CalculatorName}");
+    b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -612,22 +487,16 @@ const se_DeleteRouteCalculatorCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteRouteCalculatorCommand = se_DeleteRouteCalculatorCommand;
 const se_DeleteTrackerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tracking/v0/trackers/{TrackerName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -636,23 +505,16 @@ const se_DeleteTrackerCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteTrackerCommand = se_DeleteTrackerCommand;
 const se_DescribeGeofenceCollectionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -661,22 +523,16 @@ const se_DescribeGeofenceCollectionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_DescribeGeofenceCollectionCommand = se_DescribeGeofenceCollectionCommand;
 const se_DescribeKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata/v0/keys/{KeyName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "KeyName", () => input.KeyName, "{KeyName}", false);
+    b.bp("/metadata/v0/keys/{KeyName}");
+    b.p("KeyName", () => input.KeyName, "{KeyName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -685,22 +541,16 @@ const se_DescribeKeyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_DescribeKeyCommand = se_DescribeKeyCommand;
 const se_DescribeMapCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/maps/{MapName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
+    b.bp("/maps/v0/maps/{MapName}");
+    b.p("MapName", () => input.MapName, "{MapName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -709,22 +559,16 @@ const se_DescribeMapCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_DescribeMapCommand = se_DescribeMapCommand;
 const se_DescribePlaceIndexCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/places/v0/indexes/{IndexName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
+    b.bp("/places/v0/indexes/{IndexName}");
+    b.p("IndexName", () => input.IndexName, "{IndexName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -733,22 +577,16 @@ const se_DescribePlaceIndexCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_DescribePlaceIndexCommand = se_DescribePlaceIndexCommand;
 const se_DescribeRouteCalculatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/routes/v0/calculators/{CalculatorName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
+    b.bp("/routes/v0/calculators/{CalculatorName}");
+    b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -757,22 +595,16 @@ const se_DescribeRouteCalculatorCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_DescribeRouteCalculatorCommand = se_DescribeRouteCalculatorCommand;
 const se_DescribeTrackerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tracking/v0/trackers/{TrackerName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -781,24 +613,17 @@ const se_DescribeTrackerCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_DescribeTrackerCommand = se_DescribeTrackerCommand;
 const se_DisassociateTrackerConsumerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/consumers/{ConsumerArn}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ConsumerArn", () => input.ConsumerArn, "{ConsumerArn}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/consumers/{ConsumerArn}");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.p("ConsumerArn", () => input.ConsumerArn, "{ConsumerArn}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -807,24 +632,17 @@ const se_DisassociateTrackerConsumerCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DisassociateTrackerConsumerCommand = se_DisassociateTrackerConsumerCommand;
 const se_GetDevicePositionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/devices/{DeviceId}/positions/latest";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "DeviceId", () => input.DeviceId, "{DeviceId}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/devices/{DeviceId}/positions/latest");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -833,26 +651,19 @@ const se_GetDevicePositionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetDevicePositionCommand = se_GetDevicePositionCommand;
 const se_GetDevicePositionHistoryCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/devices/{DeviceId}/list-positions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "DeviceId", () => input.DeviceId, "{DeviceId}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/devices/{DeviceId}/list-positions");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         EndTimeExclusive: (_) => _.toISOString().split(".")[0] + "Z",
@@ -867,24 +678,17 @@ const se_GetDevicePositionHistoryCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetDevicePositionHistoryCommand = se_GetDevicePositionHistoryCommand;
 const se_GetGeofenceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}/geofences/{GeofenceId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}/geofences/{GeofenceId}");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.p("GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -893,27 +697,20 @@ const se_GetGeofenceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetGeofenceCommand = se_GetGeofenceCommand;
 const se_GetMapGlyphsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/maps/v0/maps/{MapName}/glyphs/{FontStack}/{FontUnicodeRange}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "FontStack", () => input.FontStack, "{FontStack}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "FontUnicodeRange", () => input.FontUnicodeRange, "{FontUnicodeRange}", false);
+    b.bp("/maps/v0/maps/{MapName}/glyphs/{FontStack}/{FontUnicodeRange}");
+    b.p("MapName", () => input.MapName, "{MapName}", false);
+    b.p("FontStack", () => input.FontStack, "{FontStack}", false);
+    b.p("FontUnicodeRange", () => input.FontUnicodeRange, "{FontUnicodeRange}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -923,27 +720,19 @@ const se_GetMapGlyphsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetMapGlyphsCommand = se_GetMapGlyphsCommand;
 const se_GetMapSpritesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/maps/v0/maps/{MapName}/sprites/{FileName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "FileName", () => input.FileName, "{FileName}", false);
+    b.bp("/maps/v0/maps/{MapName}/sprites/{FileName}");
+    b.p("MapName", () => input.MapName, "{MapName}", false);
+    b.p("FileName", () => input.FileName, "{FileName}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -953,25 +742,18 @@ const se_GetMapSpritesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetMapSpritesCommand = se_GetMapSpritesCommand;
 const se_GetMapStyleDescriptorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/maps/{MapName}/style-descriptor";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
+    b.bp("/maps/v0/maps/{MapName}/style-descriptor");
+    b.p("MapName", () => input.MapName, "{MapName}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -981,28 +763,21 @@ const se_GetMapStyleDescriptorCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetMapStyleDescriptorCommand = se_GetMapStyleDescriptorCommand;
 const se_GetMapTileCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/maps/{MapName}/tiles/{Z}/{X}/{Y}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Z", () => input.Z, "{Z}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "X", () => input.X, "{X}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Y", () => input.Y, "{Y}", false);
+    b.bp("/maps/v0/maps/{MapName}/tiles/{Z}/{X}/{Y}");
+    b.p("MapName", () => input.MapName, "{MapName}", false);
+    b.p("Z", () => input.Z, "{Z}", false);
+    b.p("X", () => input.X, "{X}", false);
+    b.p("Y", () => input.Y, "{Y}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1012,28 +787,20 @@ const se_GetMapTileCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetMapTileCommand = se_GetMapTileCommand;
 const se_GetPlaceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/places/v0/indexes/{IndexName}/places/{PlaceId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "PlaceId", () => input.PlaceId, "{PlaceId}", false);
+    b.bp("/places/v0/indexes/{IndexName}/places/{PlaceId}");
+    b.p("IndexName", () => input.IndexName, "{IndexName}", false);
+    b.p("PlaceId", () => input.PlaceId, "{PlaceId}", false);
     const query = (0, smithy_client_1.map)({
-        language: [, input.Language],
-        key: [, input.Key],
+        [_l]: [, input[_L]],
+        [_k]: [, input[_K]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1043,26 +810,18 @@ const se_GetPlaceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetPlaceCommand = se_GetPlaceCommand;
 const se_ListDevicePositionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/list-positions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/list-positions");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         FilterGeometry: (_) => se_TrackingFilterGeometry(_, context),
@@ -1076,23 +835,17 @@ const se_ListDevicePositionsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListDevicePositionsCommand = se_ListDevicePositionsCommand;
 const se_ListGeofenceCollectionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/geofencing/v0/list-collections";
+    b.bp("/geofencing/v0/list-collections");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         MaxResults: [],
@@ -1105,25 +858,18 @@ const se_ListGeofenceCollectionsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListGeofenceCollectionsCommand = se_ListGeofenceCollectionsCommand;
 const se_ListGeofencesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}/list-geofences";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}/list-geofences");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         MaxResults: [],
@@ -1136,23 +882,17 @@ const se_ListGeofencesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListGeofencesCommand = se_ListGeofencesCommand;
 const se_ListKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata/v0/list-keys";
+    b.bp("/metadata/v0/list-keys");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Filter: (_) => (0, smithy_client_1._json)(_),
@@ -1166,23 +906,17 @@ const se_ListKeysCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListKeysCommand = se_ListKeysCommand;
 const se_ListMapsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/list-maps";
+    b.bp("/maps/v0/list-maps");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         MaxResults: [],
@@ -1195,23 +929,17 @@ const se_ListMapsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListMapsCommand = se_ListMapsCommand;
 const se_ListPlaceIndexesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/places/v0/list-indexes";
+    b.bp("/places/v0/list-indexes");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         MaxResults: [],
@@ -1224,23 +952,17 @@ const se_ListPlaceIndexesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListPlaceIndexesCommand = se_ListPlaceIndexesCommand;
 const se_ListRouteCalculatorsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/routes/v0/list-calculators";
+    b.bp("/routes/v0/list-calculators");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         MaxResults: [],
@@ -1253,22 +975,16 @@ const se_ListRouteCalculatorsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListRouteCalculatorsCommand = se_ListRouteCalculatorsCommand;
 const se_ListTagsForResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    b.bp("/tags/{ResourceArn}");
+    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1277,25 +993,18 @@ const se_ListTagsForResourceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
 const se_ListTrackerConsumersCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/tracking/v0/trackers/{TrackerName}/list-consumers";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}/list-consumers");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         MaxResults: [],
@@ -1308,23 +1017,17 @@ const se_ListTrackerConsumersCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListTrackerConsumersCommand = se_ListTrackerConsumersCommand;
 const se_ListTrackersCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tracking/v0/list-trackers";
+    b.bp("/tracking/v0/list-trackers");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         MaxResults: [],
@@ -1337,26 +1040,19 @@ const se_ListTrackersCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_ListTrackersCommand = se_ListTrackersCommand;
 const se_PutGeofenceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}/geofences/{GeofenceId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}/geofences/{GeofenceId}");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.p("GeofenceId", () => input.GeofenceId, "{GeofenceId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         GeofenceProperties: (_) => (0, smithy_client_1._json)(_),
@@ -1369,27 +1065,20 @@ const se_PutGeofenceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 exports.se_PutGeofenceCommand = se_PutGeofenceCommand;
 const se_SearchPlaceIndexForPositionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/places/v0/indexes/{IndexName}/search/position";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
+    b.bp("/places/v0/indexes/{IndexName}/search/position");
+    b.p("IndexName", () => input.IndexName, "{IndexName}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -1404,28 +1093,20 @@ const se_SearchPlaceIndexForPositionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_SearchPlaceIndexForPositionCommand = se_SearchPlaceIndexForPositionCommand;
 const se_SearchPlaceIndexForSuggestionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/places/v0/indexes/{IndexName}/search/suggestions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
+    b.bp("/places/v0/indexes/{IndexName}/search/suggestions");
+    b.p("IndexName", () => input.IndexName, "{IndexName}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -1444,28 +1125,20 @@ const se_SearchPlaceIndexForSuggestionsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_SearchPlaceIndexForSuggestionsCommand = se_SearchPlaceIndexForSuggestionsCommand;
 const se_SearchPlaceIndexForTextCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/places/v0/indexes/{IndexName}/search/text";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
+    b.bp("/places/v0/indexes/{IndexName}/search/text");
+    b.p("IndexName", () => input.IndexName, "{IndexName}", false);
     const query = (0, smithy_client_1.map)({
-        key: [, input.Key],
+        [_k]: [, input[_K]],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -1484,25 +1157,18 @@ const se_SearchPlaceIndexForTextCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_SearchPlaceIndexForTextCommand = se_SearchPlaceIndexForTextCommand;
 const se_TagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    b.bp("/tags/{ResourceArn}");
+    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Tags: (_) => (0, smithy_client_1._json)(_),
@@ -1514,26 +1180,20 @@ const se_TagResourceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_TagResourceCommand = se_TagResourceCommand;
 const se_UntagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    b.bp("/tags/{ResourceArn}");
+    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
     const query = (0, smithy_client_1.map)({
-        tagKeys: [
+        [_tK]: [
             (0, smithy_client_1.expectNonNull)(input.TagKeys, `TagKeys`) != null,
-            () => (input.TagKeys || []).map((_entry) => _entry),
+            () => (input[_TK] || []).map((_entry) => _entry),
         ],
     });
     let body;
@@ -1544,26 +1204,18 @@ const se_UntagResourceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_UntagResourceCommand = se_UntagResourceCommand;
 const se_UpdateGeofenceCollectionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/geofencing/v0/collections/{CollectionName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CollectionName", () => input.CollectionName, "{CollectionName}", false);
+    b.bp("/geofencing/v0/collections/{CollectionName}");
+    b.p("CollectionName", () => input.CollectionName, "{CollectionName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Description: [],
@@ -1577,24 +1229,18 @@ const se_UpdateGeofenceCollectionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateGeofenceCollectionCommand = se_UpdateGeofenceCollectionCommand;
 const se_UpdateKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/metadata/v0/keys/{KeyName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "KeyName", () => input.KeyName, "{KeyName}", false);
+    b.bp("/metadata/v0/keys/{KeyName}");
+    b.p("KeyName", () => input.KeyName, "{KeyName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Description: [],
@@ -1610,24 +1256,18 @@ const se_UpdateKeyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateKeyCommand = se_UpdateKeyCommand;
 const se_UpdateMapCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/maps/v0/maps/{MapName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "MapName", () => input.MapName, "{MapName}", false);
+    b.bp("/maps/v0/maps/{MapName}");
+    b.p("MapName", () => input.MapName, "{MapName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         ConfigurationUpdate: (_) => (0, smithy_client_1._json)(_),
@@ -1641,24 +1281,18 @@ const se_UpdateMapCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateMapCommand = se_UpdateMapCommand;
 const se_UpdatePlaceIndexCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/places/v0/indexes/{IndexName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "IndexName", () => input.IndexName, "{IndexName}", false);
+    b.bp("/places/v0/indexes/{IndexName}");
+    b.p("IndexName", () => input.IndexName, "{IndexName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         DataSourceConfiguration: (_) => (0, smithy_client_1._json)(_),
@@ -1672,24 +1306,18 @@ const se_UpdatePlaceIndexCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdatePlaceIndexCommand = se_UpdatePlaceIndexCommand;
 const se_UpdateRouteCalculatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/routes/v0/calculators/{CalculatorName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
+    b.bp("/routes/v0/calculators/{CalculatorName}");
+    b.p("CalculatorName", () => input.CalculatorName, "{CalculatorName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Description: [],
@@ -1702,24 +1330,18 @@ const se_UpdateRouteCalculatorCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateRouteCalculatorCommand = se_UpdateRouteCalculatorCommand;
 const se_UpdateTrackerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tracking/v0/trackers/{TrackerName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "TrackerName", () => input.TrackerName, "{TrackerName}", false);
+    b.bp("/tracking/v0/trackers/{TrackerName}");
+    b.p("TrackerName", () => input.TrackerName, "{TrackerName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         Description: [],
@@ -1736,15 +1358,9 @@ const se_UpdateTrackerCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateTrackerCommand = se_UpdateTrackerCommand;
 const de_AssociateTrackerConsumerCommand = async (output, context) => {
@@ -3252,8 +2868,8 @@ const de_GetMapGlyphsCommand = async (output, context) => {
     }
     const contents = (0, smithy_client_1.map)({
         $metadata: deserializeMetadata(output),
-        ContentType: [, output.headers["content-type"]],
-        CacheControl: [, output.headers["cache-control"]],
+        [_CT]: [, output.headers[_ct]],
+        [_CC]: [, output.headers[_cc]],
     });
     const data = await (0, smithy_client_1.collectBody)(output.body, context);
     contents.Blob = data;
@@ -3297,8 +2913,8 @@ const de_GetMapSpritesCommand = async (output, context) => {
     }
     const contents = (0, smithy_client_1.map)({
         $metadata: deserializeMetadata(output),
-        ContentType: [, output.headers["content-type"]],
-        CacheControl: [, output.headers["cache-control"]],
+        [_CT]: [, output.headers[_ct]],
+        [_CC]: [, output.headers[_cc]],
     });
     const data = await (0, smithy_client_1.collectBody)(output.body, context);
     contents.Blob = data;
@@ -3342,8 +2958,8 @@ const de_GetMapStyleDescriptorCommand = async (output, context) => {
     }
     const contents = (0, smithy_client_1.map)({
         $metadata: deserializeMetadata(output),
-        ContentType: [, output.headers["content-type"]],
-        CacheControl: [, output.headers["cache-control"]],
+        [_CT]: [, output.headers[_ct]],
+        [_CC]: [, output.headers[_cc]],
     });
     const data = await (0, smithy_client_1.collectBody)(output.body, context);
     contents.Blob = data;
@@ -3387,8 +3003,8 @@ const de_GetMapTileCommand = async (output, context) => {
     }
     const contents = (0, smithy_client_1.map)({
         $metadata: deserializeMetadata(output),
-        ContentType: [, output.headers["content-type"]],
-        CacheControl: [, output.headers["cache-control"]],
+        [_CT]: [, output.headers[_ct]],
+        [_CC]: [, output.headers[_cc]],
     });
     const data = await (0, smithy_client_1.collectBody)(output.body, context);
     contents.Blob = data;
@@ -5153,6 +4769,16 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _CC = "CacheControl";
+const _CT = "ContentType";
+const _K = "Key";
+const _L = "Language";
+const _TK = "TagKeys";
+const _cc = "cache-control";
+const _ct = "content-type";
+const _k = "key";
+const _l = "language";
+const _tK = "tagKeys";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);