@aws-sdk/client-iotsitewise 3.474.0 → 3.477.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -4,6 +4,7 @@ exports.se_GetAssetPropertyValueHistoryCommand = exports.se_GetAssetPropertyValu
 exports.de_CreatePortalCommand = exports.de_CreateGatewayCommand = exports.de_CreateDashboardCommand = exports.de_CreateBulkImportJobCommand = exports.de_CreateAssetModelCompositeModelCommand = exports.de_CreateAssetModelCommand = exports.de_CreateAssetCommand = exports.de_CreateAccessPolicyCommand = exports.de_BatchPutAssetPropertyValueCommand = exports.de_BatchGetAssetPropertyValueHistoryCommand = exports.de_BatchGetAssetPropertyValueCommand = exports.de_BatchGetAssetPropertyAggregatesCommand = exports.de_BatchDisassociateProjectAssetsCommand = exports.de_BatchAssociateProjectAssetsCommand = exports.de_AssociateTimeSeriesToAssetPropertyCommand = exports.de_AssociateAssetsCommand = exports.se_UpdateProjectCommand = exports.se_UpdatePortalCommand = exports.se_UpdateGatewayCapabilityConfigurationCommand = exports.se_UpdateGatewayCommand = exports.se_UpdateDashboardCommand = exports.se_UpdateAssetPropertyCommand = exports.se_UpdateAssetModelCompositeModelCommand = exports.se_UpdateAssetModelCommand = exports.se_UpdateAssetCommand = exports.se_UpdateAccessPolicyCommand = exports.se_UntagResourceCommand = exports.se_TagResourceCommand = exports.se_PutStorageConfigurationCommand = exports.se_PutLoggingOptionsCommand = exports.se_PutDefaultEncryptionConfigurationCommand = exports.se_ListTimeSeriesCommand = exports.se_ListTagsForResourceCommand = exports.se_ListProjectsCommand = exports.se_ListProjectAssetsCommand = exports.se_ListPortalsCommand = exports.se_ListGatewaysCommand = exports.se_ListDashboardsCommand = exports.se_ListCompositionRelationshipsCommand = exports.se_ListBulkImportJobsCommand = exports.se_ListAssociatedAssetsCommand = exports.se_ListAssetsCommand = exports.se_ListAssetRelationshipsCommand = exports.se_ListAssetPropertiesCommand = exports.se_ListAssetModelsCommand = exports.se_ListAssetModelPropertiesCommand = exports.se_ListAssetModelCompositeModelsCommand = exports.se_ListActionsCommand = exports.se_ListAccessPoliciesCommand = exports.se_GetInterpolatedAssetPropertyValuesCommand = void 0;
 exports.de_ListProjectAssetsCommand = exports.de_ListPortalsCommand = exports.de_ListGatewaysCommand = exports.de_ListDashboardsCommand = exports.de_ListCompositionRelationshipsCommand = exports.de_ListBulkImportJobsCommand = exports.de_ListAssociatedAssetsCommand = exports.de_ListAssetsCommand = exports.de_ListAssetRelationshipsCommand = exports.de_ListAssetPropertiesCommand = exports.de_ListAssetModelsCommand = exports.de_ListAssetModelPropertiesCommand = exports.de_ListAssetModelCompositeModelsCommand = exports.de_ListActionsCommand = exports.de_ListAccessPoliciesCommand = exports.de_GetInterpolatedAssetPropertyValuesCommand = exports.de_GetAssetPropertyValueHistoryCommand = exports.de_GetAssetPropertyValueCommand = exports.de_GetAssetPropertyAggregatesCommand = exports.de_ExecuteQueryCommand = exports.de_ExecuteActionCommand = exports.de_DisassociateTimeSeriesFromAssetPropertyCommand = exports.de_DisassociateAssetsCommand = exports.de_DescribeTimeSeriesCommand = exports.de_DescribeStorageConfigurationCommand = exports.de_DescribeProjectCommand = exports.de_DescribePortalCommand = exports.de_DescribeLoggingOptionsCommand = exports.de_DescribeGatewayCapabilityConfigurationCommand = exports.de_DescribeGatewayCommand = exports.de_DescribeDefaultEncryptionConfigurationCommand = exports.de_DescribeDashboardCommand = exports.de_DescribeBulkImportJobCommand = exports.de_DescribeAssetPropertyCommand = exports.de_DescribeAssetModelCompositeModelCommand = exports.de_DescribeAssetModelCommand = exports.de_DescribeAssetCompositeModelCommand = exports.de_DescribeAssetCommand = exports.de_DescribeActionCommand = exports.de_DescribeAccessPolicyCommand = exports.de_DeleteTimeSeriesCommand = exports.de_DeleteProjectCommand = exports.de_DeletePortalCommand = exports.de_DeleteGatewayCommand = exports.de_DeleteDashboardCommand = exports.de_DeleteAssetModelCompositeModelCommand = exports.de_DeleteAssetModelCommand = exports.de_DeleteAssetCommand = exports.de_DeleteAccessPolicyCommand = exports.de_CreateProjectCommand = void 0;
 exports.de_UpdateProjectCommand = exports.de_UpdatePortalCommand = exports.de_UpdateGatewayCapabilityConfigurationCommand = exports.de_UpdateGatewayCommand = exports.de_UpdateDashboardCommand = exports.de_UpdateAssetPropertyCommand = exports.de_UpdateAssetModelCompositeModelCommand = exports.de_UpdateAssetModelCommand = exports.de_UpdateAssetCommand = exports.de_UpdateAccessPolicyCommand = exports.de_UntagResourceCommand = exports.de_TagResourceCommand = exports.de_PutStorageConfigurationCommand = exports.de_PutLoggingOptionsCommand = exports.de_PutDefaultEncryptionConfigurationCommand = exports.de_ListTimeSeriesCommand = exports.de_ListTagsForResourceCommand = exports.de_ListProjectsCommand = 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 uuid_1 = require("uuid");
@@ -11,12 +12,12 @@ const IoTSiteWiseServiceException_1 = require("../models/IoTSiteWiseServiceExcep
 const models_0_1 = require("../models/models_0");
 const models_1_1 = require("../models/models_1");
 const se_AssociateAssetsCommand = 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 || ""}` + "/assets/{assetId}/associate";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/associate");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         childAssetId: [],
@@ -30,27 +31,21 @@ const se_AssociateAssetsCommand = 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_AssociateAssetsCommand = se_AssociateAssetsCommand;
 const se_AssociateTimeSeriesToAssetPropertyCommand = 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 || ""}` + "/timeseries/associate";
+    b.bp("/timeseries/associate");
     const query = (0, smithy_client_1.map)({
-        alias: [, (0, smithy_client_1.expectNonNull)(input.alias, `alias`)],
-        assetId: [, (0, smithy_client_1.expectNonNull)(input.assetId, `assetId`)],
-        propertyId: [, (0, smithy_client_1.expectNonNull)(input.propertyId, `propertyId`)],
+        [_a]: [, (0, smithy_client_1.expectNonNull)(input[_a], `alias`)],
+        [_aI]: [, (0, smithy_client_1.expectNonNull)(input[_aI], `assetId`)],
+        [_pI]: [, (0, smithy_client_1.expectNonNull)(input[_pI], `propertyId`)],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -63,25 +58,18 @@ const se_AssociateTimeSeriesToAssetPropertyCommand = 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_AssociateTimeSeriesToAssetPropertyCommand = se_AssociateTimeSeriesToAssetPropertyCommand;
 const se_BatchAssociateProjectAssetsCommand = 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 || ""}` + "/projects/{projectId}/assets/associate";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}/assets/associate");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetIds: (_) => (0, smithy_client_1._json)(_),
@@ -94,24 +82,18 @@ const se_BatchAssociateProjectAssetsCommand = 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_BatchAssociateProjectAssetsCommand = se_BatchAssociateProjectAssetsCommand;
 const se_BatchDisassociateProjectAssetsCommand = 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 || ""}` + "/projects/{projectId}/assets/disassociate";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}/assets/disassociate");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetIds: (_) => (0, smithy_client_1._json)(_),
@@ -124,23 +106,17 @@ const se_BatchDisassociateProjectAssetsCommand = 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_BatchDisassociateProjectAssetsCommand = se_BatchDisassociateProjectAssetsCommand;
 const se_BatchGetAssetPropertyAggregatesCommand = 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 || ""}` + "/properties/batch/aggregates";
+    b.bp("/properties/batch/aggregates");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         entries: (_) => se_BatchGetAssetPropertyAggregatesEntries(_, context),
@@ -154,23 +130,17 @@ const se_BatchGetAssetPropertyAggregatesCommand = 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_BatchGetAssetPropertyAggregatesCommand = se_BatchGetAssetPropertyAggregatesCommand;
 const se_BatchGetAssetPropertyValueCommand = 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 || ""}` + "/properties/batch/latest";
+    b.bp("/properties/batch/latest");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         entries: (_) => (0, smithy_client_1._json)(_),
@@ -183,23 +153,17 @@ const se_BatchGetAssetPropertyValueCommand = 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_BatchGetAssetPropertyValueCommand = se_BatchGetAssetPropertyValueCommand;
 const se_BatchGetAssetPropertyValueHistoryCommand = 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 || ""}` + "/properties/batch/history";
+    b.bp("/properties/batch/history");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         entries: (_) => se_BatchGetAssetPropertyValueHistoryEntries(_, context),
@@ -213,23 +177,17 @@ const se_BatchGetAssetPropertyValueHistoryCommand = 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_BatchGetAssetPropertyValueHistoryCommand = se_BatchGetAssetPropertyValueHistoryCommand;
 const se_BatchPutAssetPropertyValueCommand = 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 || ""}` + "/properties";
+    b.bp("/properties");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         entries: (_) => se_PutAssetPropertyValueEntries(_, context),
@@ -241,23 +199,17 @@ const se_BatchPutAssetPropertyValueCommand = 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_BatchPutAssetPropertyValueCommand = se_BatchPutAssetPropertyValueCommand;
 const se_CreateAccessPolicyCommand = 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 || ""}` + "/access-policies";
+    b.bp("/access-policies");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         accessPolicyIdentity: (_) => (0, smithy_client_1._json)(_),
@@ -273,23 +225,17 @@ const se_CreateAccessPolicyCommand = 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_CreateAccessPolicyCommand = se_CreateAccessPolicyCommand;
 const se_CreateAssetCommand = 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 || ""}` + "/assets";
+    b.bp("/assets");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetDescription: [],
@@ -307,23 +253,17 @@ const se_CreateAssetCommand = 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_CreateAssetCommand = se_CreateAssetCommand;
 const se_CreateAssetModelCommand = 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 || ""}` + "/asset-models";
+    b.bp("/asset-models");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetModelCompositeModels: (_) => se_AssetModelCompositeModelDefinitions(_, context),
@@ -344,25 +284,18 @@ const se_CreateAssetModelCommand = 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_CreateAssetModelCommand = se_CreateAssetModelCommand;
 const se_CreateAssetModelCompositeModelCommand = 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 || ""}` +
-        "/asset-models/{assetModelId}/composite-models";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composite-models");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetModelCompositeModelDescription: [],
@@ -382,23 +315,17 @@ const se_CreateAssetModelCompositeModelCommand = 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_CreateAssetModelCompositeModelCommand = se_CreateAssetModelCompositeModelCommand;
 const se_CreateBulkImportJobCommand = 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 || ""}` + "/jobs";
+    b.bp("/jobs");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         adaptiveIngestion: [],
@@ -416,23 +343,17 @@ const se_CreateBulkImportJobCommand = 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_CreateBulkImportJobCommand = se_CreateBulkImportJobCommand;
 const se_CreateDashboardCommand = 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 || ""}` + "/dashboards";
+    b.bp("/dashboards");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -449,23 +370,17 @@ const se_CreateDashboardCommand = 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_CreateDashboardCommand = se_CreateDashboardCommand;
 const se_CreateGatewayCommand = 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 || ""}` + "/20200301/gateways";
+    b.bp("/20200301/gateways");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         gatewayName: [],
@@ -479,23 +394,17 @@ const se_CreateGatewayCommand = 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_CreateGatewayCommand = se_CreateGatewayCommand;
 const se_CreatePortalCommand = 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 || ""}` + "/portals";
+    b.bp("/portals");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         alarms: (_) => (0, smithy_client_1._json)(_),
@@ -516,23 +425,17 @@ const se_CreatePortalCommand = 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_CreatePortalCommand = se_CreatePortalCommand;
 const se_CreateProjectCommand = 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 || ""}` + "/projects";
+    b.bp("/projects");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -548,24 +451,18 @@ const se_CreateProjectCommand = 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_CreateProjectCommand = se_CreateProjectCommand;
 const se_DeleteAccessPolicyCommand = 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 || ""}` + "/access-policies/{accessPolicyId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
+    b.bp("/access-policies/{accessPolicyId}");
+    b.p("accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
     const query = (0, smithy_client_1.map)({
-        clientToken: [, input.clientToken ?? (0, uuid_1.v4)()],
+        [_cT]: [, input[_cT] ?? (0, uuid_1.v4)()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -575,25 +472,18 @@ const se_DeleteAccessPolicyCommand = 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_DeleteAccessPolicyCommand = se_DeleteAccessPolicyCommand;
 const se_DeleteAssetCommand = 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 || ""}` + "/assets/{assetId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = (0, smithy_client_1.map)({
-        clientToken: [, input.clientToken ?? (0, uuid_1.v4)()],
+        [_cT]: [, input[_cT] ?? (0, uuid_1.v4)()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -603,25 +493,18 @@ const se_DeleteAssetCommand = 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_DeleteAssetCommand = se_DeleteAssetCommand;
 const se_DeleteAssetModelCommand = 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 || ""}` + "/asset-models/{assetModelId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = (0, smithy_client_1.map)({
-        clientToken: [, input.clientToken ?? (0, uuid_1.v4)()],
+        [_cT]: [, input[_cT] ?? (0, uuid_1.v4)()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -631,27 +514,19 @@ const se_DeleteAssetModelCommand = 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_DeleteAssetModelCommand = se_DeleteAssetModelCommand;
 const se_DeleteAssetModelCompositeModelCommand = 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 || ""}` +
-        "/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelCompositeModelId", () => input.assetModelCompositeModelId, "{assetModelCompositeModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.p("assetModelCompositeModelId", () => input.assetModelCompositeModelId, "{assetModelCompositeModelId}", false);
     const query = (0, smithy_client_1.map)({
-        clientToken: [, input.clientToken ?? (0, uuid_1.v4)()],
+        [_cT]: [, input[_cT] ?? (0, uuid_1.v4)()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -661,25 +536,18 @@ const se_DeleteAssetModelCompositeModelCommand = 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_DeleteAssetModelCompositeModelCommand = se_DeleteAssetModelCompositeModelCommand;
 const se_DeleteDashboardCommand = 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 || ""}` + "/dashboards/{dashboardId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "dashboardId", () => input.dashboardId, "{dashboardId}", false);
+    b.bp("/dashboards/{dashboardId}");
+    b.p("dashboardId", () => input.dashboardId, "{dashboardId}", false);
     const query = (0, smithy_client_1.map)({
-        clientToken: [, input.clientToken ?? (0, uuid_1.v4)()],
+        [_cT]: [, input[_cT] ?? (0, uuid_1.v4)()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -689,23 +557,16 @@ const se_DeleteDashboardCommand = 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_DeleteDashboardCommand = se_DeleteDashboardCommand;
 const se_DeleteGatewayCommand = 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 || ""}` + "/20200301/gateways/{gatewayId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayId", () => input.gatewayId, "{gatewayId}", false);
+    b.bp("/20200301/gateways/{gatewayId}");
+    b.p("gatewayId", () => input.gatewayId, "{gatewayId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -714,24 +575,18 @@ const se_DeleteGatewayCommand = 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_DeleteGatewayCommand = se_DeleteGatewayCommand;
 const se_DeletePortalCommand = 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 || ""}` + "/portals/{portalId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "portalId", () => input.portalId, "{portalId}", false);
+    b.bp("/portals/{portalId}");
+    b.p("portalId", () => input.portalId, "{portalId}", false);
     const query = (0, smithy_client_1.map)({
-        clientToken: [, input.clientToken ?? (0, uuid_1.v4)()],
+        [_cT]: [, input[_cT] ?? (0, uuid_1.v4)()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -741,25 +596,18 @@ const se_DeletePortalCommand = 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_DeletePortalCommand = se_DeletePortalCommand;
 const se_DeleteProjectCommand = 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 || ""}` + "/projects/{projectId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     const query = (0, smithy_client_1.map)({
-        clientToken: [, input.clientToken ?? (0, uuid_1.v4)()],
+        [_cT]: [, input[_cT] ?? (0, uuid_1.v4)()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -769,28 +617,21 @@ const se_DeleteProjectCommand = 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_DeleteProjectCommand = se_DeleteProjectCommand;
 const se_DeleteTimeSeriesCommand = 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 || ""}` + "/timeseries/delete";
+    b.bp("/timeseries/delete");
     const query = (0, smithy_client_1.map)({
-        alias: [, input.alias],
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
+        [_a]: [, input[_a]],
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -803,23 +644,16 @@ const se_DeleteTimeSeriesCommand = 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_DeleteTimeSeriesCommand = se_DeleteTimeSeriesCommand;
 const se_DescribeAccessPolicyCommand = 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 || ""}` + "/access-policies/{accessPolicyId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
+    b.bp("/access-policies/{accessPolicyId}");
+    b.p("accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -828,22 +662,16 @@ const se_DescribeAccessPolicyCommand = 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_DescribeAccessPolicyCommand = se_DescribeAccessPolicyCommand;
 const se_DescribeActionCommand = 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 || ""}` + "/actions/{actionId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "actionId", () => input.actionId, "{actionId}", false);
+    b.bp("/actions/{actionId}");
+    b.p("actionId", () => input.actionId, "{actionId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -852,24 +680,18 @@ const se_DescribeActionCommand = 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_DescribeActionCommand = se_DescribeActionCommand;
 const se_DescribeAssetCommand = 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 || ""}` + "/assets/{assetId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = (0, smithy_client_1.map)({
-        excludeProperties: [() => input.excludeProperties !== void 0, () => input.excludeProperties.toString()],
+        [_eP]: [() => input.excludeProperties !== void 0, () => input[_eP].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -879,25 +701,17 @@ const se_DescribeAssetCommand = 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_DescribeAssetCommand = se_DescribeAssetCommand;
 const se_DescribeAssetCompositeModelCommand = 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 || ""}` +
-        "/assets/{assetId}/composite-models/{assetCompositeModelId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetCompositeModelId", () => input.assetCompositeModelId, "{assetCompositeModelId}", false);
+    b.bp("/assets/{assetId}/composite-models/{assetCompositeModelId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
+    b.p("assetCompositeModelId", () => input.assetCompositeModelId, "{assetCompositeModelId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -906,24 +720,18 @@ const se_DescribeAssetCompositeModelCommand = 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_DescribeAssetCompositeModelCommand = se_DescribeAssetCompositeModelCommand;
 const se_DescribeAssetModelCommand = 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 || ""}` + "/asset-models/{assetModelId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = (0, smithy_client_1.map)({
-        excludeProperties: [() => input.excludeProperties !== void 0, () => input.excludeProperties.toString()],
+        [_eP]: [() => input.excludeProperties !== void 0, () => input[_eP].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -933,25 +741,17 @@ const se_DescribeAssetModelCommand = 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_DescribeAssetModelCommand = se_DescribeAssetModelCommand;
 const se_DescribeAssetModelCompositeModelCommand = 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 || ""}` +
-        "/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelCompositeModelId", () => input.assetModelCompositeModelId, "{assetModelCompositeModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.p("assetModelCompositeModelId", () => input.assetModelCompositeModelId, "{assetModelCompositeModelId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -960,23 +760,17 @@ const se_DescribeAssetModelCompositeModelCommand = 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_DescribeAssetModelCompositeModelCommand = se_DescribeAssetModelCompositeModelCommand;
 const se_DescribeAssetPropertyCommand = 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 || ""}` + "/assets/{assetId}/properties/{propertyId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "propertyId", () => input.propertyId, "{propertyId}", false);
+    b.bp("/assets/{assetId}/properties/{propertyId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
+    b.p("propertyId", () => input.propertyId, "{propertyId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -985,22 +779,16 @@ const se_DescribeAssetPropertyCommand = 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_DescribeAssetPropertyCommand = se_DescribeAssetPropertyCommand;
 const se_DescribeBulkImportJobCommand = 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 || ""}` + "/jobs/{jobId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "jobId", () => input.jobId, "{jobId}", false);
+    b.bp("/jobs/{jobId}");
+    b.p("jobId", () => input.jobId, "{jobId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1009,22 +797,16 @@ const se_DescribeBulkImportJobCommand = 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_DescribeBulkImportJobCommand = se_DescribeBulkImportJobCommand;
 const se_DescribeDashboardCommand = 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 || ""}` + "/dashboards/{dashboardId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "dashboardId", () => input.dashboardId, "{dashboardId}", false);
+    b.bp("/dashboards/{dashboardId}");
+    b.p("dashboardId", () => input.dashboardId, "{dashboardId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1033,23 +815,17 @@ const se_DescribeDashboardCommand = 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_DescribeDashboardCommand = se_DescribeDashboardCommand;
 const se_DescribeDefaultEncryptionConfigurationCommand = 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 || ""}` + "/configuration/account/encryption";
+    b.bp("/configuration/account/encryption");
     let body;
     body = "";
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1059,22 +835,16 @@ const se_DescribeDefaultEncryptionConfigurationCommand = 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_DescribeDefaultEncryptionConfigurationCommand = se_DescribeDefaultEncryptionConfigurationCommand;
 const se_DescribeGatewayCommand = 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 || ""}` + "/20200301/gateways/{gatewayId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayId", () => input.gatewayId, "{gatewayId}", false);
+    b.bp("/20200301/gateways/{gatewayId}");
+    b.p("gatewayId", () => input.gatewayId, "{gatewayId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1083,24 +853,17 @@ const se_DescribeGatewayCommand = 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_DescribeGatewayCommand = se_DescribeGatewayCommand;
 const se_DescribeGatewayCapabilityConfigurationCommand = 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 || ""}` +
-        "/20200301/gateways/{gatewayId}/capability/{capabilityNamespace}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayId", () => input.gatewayId, "{gatewayId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "capabilityNamespace", () => input.capabilityNamespace, "{capabilityNamespace}", false);
+    b.bp("/20200301/gateways/{gatewayId}/capability/{capabilityNamespace}");
+    b.p("gatewayId", () => input.gatewayId, "{gatewayId}", false);
+    b.p("capabilityNamespace", () => input.capabilityNamespace, "{capabilityNamespace}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1109,23 +872,17 @@ const se_DescribeGatewayCapabilityConfigurationCommand = 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_DescribeGatewayCapabilityConfigurationCommand = se_DescribeGatewayCapabilityConfigurationCommand;
 const se_DescribeLoggingOptionsCommand = 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 || ""}` + "/logging";
+    b.bp("/logging");
     let body;
     body = "";
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1135,22 +892,16 @@ const se_DescribeLoggingOptionsCommand = 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_DescribeLoggingOptionsCommand = se_DescribeLoggingOptionsCommand;
 const se_DescribePortalCommand = 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 || ""}` + "/portals/{portalId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "portalId", () => input.portalId, "{portalId}", false);
+    b.bp("/portals/{portalId}");
+    b.p("portalId", () => input.portalId, "{portalId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1159,22 +910,16 @@ const se_DescribePortalCommand = 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_DescribePortalCommand = se_DescribePortalCommand;
 const se_DescribeProjectCommand = 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 || ""}` + "/projects/{projectId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1183,23 +928,17 @@ const se_DescribeProjectCommand = 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_DescribeProjectCommand = se_DescribeProjectCommand;
 const se_DescribeStorageConfigurationCommand = 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 || ""}` + "/configuration/account/storage";
+    b.bp("/configuration/account/storage");
     let body;
     body = "";
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1209,25 +948,19 @@ const se_DescribeStorageConfigurationCommand = 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_DescribeStorageConfigurationCommand = se_DescribeStorageConfigurationCommand;
 const se_DescribeTimeSeriesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/timeseries/describe";
+    b.bp("/timeseries/describe");
     const query = (0, smithy_client_1.map)({
-        alias: [, input.alias],
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
+        [_a]: [, input[_a]],
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1237,25 +970,18 @@ const se_DescribeTimeSeriesCommand = 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_DescribeTimeSeriesCommand = se_DescribeTimeSeriesCommand;
 const se_DisassociateAssetsCommand = 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 || ""}` + "/assets/{assetId}/disassociate";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/disassociate");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         childAssetId: [],
@@ -1269,27 +995,21 @@ const se_DisassociateAssetsCommand = 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_DisassociateAssetsCommand = se_DisassociateAssetsCommand;
 const se_DisassociateTimeSeriesFromAssetPropertyCommand = 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 || ""}` + "/timeseries/disassociate";
+    b.bp("/timeseries/disassociate");
     const query = (0, smithy_client_1.map)({
-        alias: [, (0, smithy_client_1.expectNonNull)(input.alias, `alias`)],
-        assetId: [, (0, smithy_client_1.expectNonNull)(input.assetId, `assetId`)],
-        propertyId: [, (0, smithy_client_1.expectNonNull)(input.propertyId, `propertyId`)],
+        [_a]: [, (0, smithy_client_1.expectNonNull)(input[_a], `alias`)],
+        [_aI]: [, (0, smithy_client_1.expectNonNull)(input[_aI], `assetId`)],
+        [_pI]: [, (0, smithy_client_1.expectNonNull)(input[_pI], `propertyId`)],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -1302,24 +1022,17 @@ const se_DisassociateTimeSeriesFromAssetPropertyCommand = 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_DisassociateTimeSeriesFromAssetPropertyCommand = se_DisassociateTimeSeriesFromAssetPropertyCommand;
 const se_ExecuteActionCommand = 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 || ""}` + "/actions";
+    b.bp("/actions");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         actionDefinitionId: [],
@@ -1334,23 +1047,17 @@ const se_ExecuteActionCommand = 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_ExecuteActionCommand = se_ExecuteActionCommand;
 const se_ExecuteQueryCommand = 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 || ""}` + "/queries/execution";
+    b.bp("/queries/execution");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         maxResults: [],
@@ -1364,42 +1071,36 @@ const se_ExecuteQueryCommand = 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_ExecuteQueryCommand = se_ExecuteQueryCommand;
 const se_GetAssetPropertyAggregatesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/aggregates";
+    b.bp("/properties/aggregates");
     const query = (0, smithy_client_1.map)({
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
-        propertyAlias: [, input.propertyAlias],
-        aggregateTypes: [
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
+        [_pA]: [, input[_pA]],
+        [_aT]: [
             (0, smithy_client_1.expectNonNull)(input.aggregateTypes, `aggregateTypes`) != null,
-            () => (input.aggregateTypes || []).map((_entry) => _entry),
+            () => (input[_aT] || []).map((_entry) => _entry),
         ],
-        resolution: [, (0, smithy_client_1.expectNonNull)(input.resolution, `resolution`)],
-        qualities: [() => input.qualities !== void 0, () => (input.qualities || []).map((_entry) => _entry)],
-        startDate: [
+        [_r]: [, (0, smithy_client_1.expectNonNull)(input[_r], `resolution`)],
+        [_q]: [() => input.qualities !== void 0, () => (input[_q] || []).map((_entry) => _entry)],
+        [_sD]: [
             (0, smithy_client_1.expectNonNull)(input.startDate, `startDate`) != null,
-            () => (input.startDate.toISOString().split(".")[0] + "Z").toString(),
+            () => (input[_sD].toISOString().split(".")[0] + "Z").toString(),
         ],
-        endDate: [
+        [_eD]: [
             (0, smithy_client_1.expectNonNull)(input.endDate, `endDate`) != null,
-            () => (input.endDate.toISOString().split(".")[0] + "Z").toString(),
+            () => (input[_eD].toISOString().split(".")[0] + "Z").toString(),
         ],
-        timeOrdering: [, input.timeOrdering],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_tO]: [, input[_tO]],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1409,26 +1110,19 @@ const se_GetAssetPropertyAggregatesCommand = 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_GetAssetPropertyAggregatesCommand = se_GetAssetPropertyAggregatesCommand;
 const se_GetAssetPropertyValueCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/latest";
+    b.bp("/properties/latest");
     const query = (0, smithy_client_1.map)({
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
-        propertyAlias: [, input.propertyAlias],
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
+        [_pA]: [, input[_pA]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1438,35 +1132,25 @@ const se_GetAssetPropertyValueCommand = 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_GetAssetPropertyValueCommand = se_GetAssetPropertyValueCommand;
 const se_GetAssetPropertyValueHistoryCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/history";
+    b.bp("/properties/history");
     const query = (0, smithy_client_1.map)({
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
-        propertyAlias: [, input.propertyAlias],
-        startDate: [
-            () => input.startDate !== void 0,
-            () => (input.startDate.toISOString().split(".")[0] + "Z").toString(),
-        ],
-        endDate: [() => input.endDate !== void 0, () => (input.endDate.toISOString().split(".")[0] + "Z").toString()],
-        qualities: [() => input.qualities !== void 0, () => (input.qualities || []).map((_entry) => _entry)],
-        timeOrdering: [, input.timeOrdering],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
+        [_pA]: [, input[_pA]],
+        [_sD]: [() => input.startDate !== void 0, () => (input[_sD].toISOString().split(".")[0] + "Z").toString()],
+        [_eD]: [() => input.endDate !== void 0, () => (input[_eD].toISOString().split(".")[0] + "Z").toString()],
+        [_q]: [() => input.qualities !== void 0, () => (input[_q] || []).map((_entry) => _entry)],
+        [_tO]: [, input[_tO]],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1476,51 +1160,29 @@ const se_GetAssetPropertyValueHistoryCommand = 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_GetAssetPropertyValueHistoryCommand = se_GetAssetPropertyValueHistoryCommand;
 const se_GetInterpolatedAssetPropertyValuesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/interpolated";
+    b.bp("/properties/interpolated");
     const query = (0, smithy_client_1.map)({
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
-        propertyAlias: [, input.propertyAlias],
-        startTimeInSeconds: [
-            (0, smithy_client_1.expectNonNull)(input.startTimeInSeconds, `startTimeInSeconds`) != null,
-            () => input.startTimeInSeconds.toString(),
-        ],
-        startTimeOffsetInNanos: [
-            () => input.startTimeOffsetInNanos !== void 0,
-            () => input.startTimeOffsetInNanos.toString(),
-        ],
-        endTimeInSeconds: [
-            (0, smithy_client_1.expectNonNull)(input.endTimeInSeconds, `endTimeInSeconds`) != null,
-            () => input.endTimeInSeconds.toString(),
-        ],
-        endTimeOffsetInNanos: [() => input.endTimeOffsetInNanos !== void 0, () => input.endTimeOffsetInNanos.toString()],
-        quality: [, (0, smithy_client_1.expectNonNull)(input.quality, `quality`)],
-        intervalInSeconds: [
-            (0, smithy_client_1.expectNonNull)(input.intervalInSeconds, `intervalInSeconds`) != null,
-            () => input.intervalInSeconds.toString(),
-        ],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        type: [, (0, smithy_client_1.expectNonNull)(input.type, `type`)],
-        intervalWindowInSeconds: [
-            () => input.intervalWindowInSeconds !== void 0,
-            () => input.intervalWindowInSeconds.toString(),
-        ],
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
+        [_pA]: [, input[_pA]],
+        [_sTIS]: [(0, smithy_client_1.expectNonNull)(input.startTimeInSeconds, `startTimeInSeconds`) != null, () => input[_sTIS].toString()],
+        [_sTOIN]: [() => input.startTimeOffsetInNanos !== void 0, () => input[_sTOIN].toString()],
+        [_eTIS]: [(0, smithy_client_1.expectNonNull)(input.endTimeInSeconds, `endTimeInSeconds`) != null, () => input[_eTIS].toString()],
+        [_eTOIN]: [() => input.endTimeOffsetInNanos !== void 0, () => input[_eTOIN].toString()],
+        [_qu]: [, (0, smithy_client_1.expectNonNull)(input[_qu], `quality`)],
+        [_iIS]: [(0, smithy_client_1.expectNonNull)(input.intervalInSeconds, `intervalInSeconds`) != null, () => input[_iIS].toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_t]: [, (0, smithy_client_1.expectNonNull)(input[_t], `type`)],
+        [_iWIS]: [() => input.intervalWindowInSeconds !== void 0, () => input[_iWIS].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1530,30 +1192,23 @@ const se_GetInterpolatedAssetPropertyValuesCommand = 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_GetInterpolatedAssetPropertyValuesCommand = se_GetInterpolatedAssetPropertyValuesCommand;
 const se_ListAccessPoliciesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/access-policies";
+    b.bp("/access-policies");
     const query = (0, smithy_client_1.map)({
-        identityType: [, input.identityType],
-        identityId: [, input.identityId],
-        resourceType: [, input.resourceType],
-        resourceId: [, input.resourceId],
-        iamArn: [, input.iamArn],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_iT]: [, input[_iT]],
+        [_iI]: [, input[_iI]],
+        [_rT]: [, input[_rT]],
+        [_rI]: [, input[_rI]],
+        [_iA]: [, input[_iA]],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1563,27 +1218,20 @@ const se_ListAccessPoliciesCommand = 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_ListAccessPoliciesCommand = se_ListAccessPoliciesCommand;
 const se_ListActionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actions";
+    b.bp("/actions");
     const query = (0, smithy_client_1.map)({
-        targetResourceType: [, (0, smithy_client_1.expectNonNull)(input.targetResourceType, `targetResourceType`)],
-        targetResourceId: [, (0, smithy_client_1.expectNonNull)(input.targetResourceId, `targetResourceId`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_tRT]: [, (0, smithy_client_1.expectNonNull)(input[_tRT], `targetResourceType`)],
+        [_tRI]: [, (0, smithy_client_1.expectNonNull)(input[_tRI], `targetResourceId`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1593,27 +1241,19 @@ const se_ListActionsCommand = 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_ListActionsCommand = se_ListActionsCommand;
 const se_ListAssetModelCompositeModelsCommand = 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 || ""}` +
-        "/asset-models/{assetModelId}/composite-models";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composite-models");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1623,27 +1263,20 @@ const se_ListAssetModelCompositeModelsCommand = 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_ListAssetModelCompositeModelsCommand = se_ListAssetModelCompositeModelsCommand;
 const se_ListAssetModelPropertiesCommand = 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 || ""}` + "/asset-models/{assetModelId}/properties";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}/properties");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        filter: [, input.filter],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_f]: [, input[_f]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1653,29 +1286,19 @@ const se_ListAssetModelPropertiesCommand = 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_ListAssetModelPropertiesCommand = se_ListAssetModelPropertiesCommand;
 const se_ListAssetModelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/asset-models";
+    b.bp("/asset-models");
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        assetModelTypes: [
-            () => input.assetModelTypes !== void 0,
-            () => (input.assetModelTypes || []).map((_entry) => _entry),
-        ],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_aMT]: [() => input.assetModelTypes !== void 0, () => (input[_aMT] || []).map((_entry) => _entry)],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1685,27 +1308,20 @@ const se_ListAssetModelsCommand = 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_ListAssetModelsCommand = se_ListAssetModelsCommand;
 const se_ListAssetPropertiesCommand = 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 || ""}` + "/assets/{assetId}/properties";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/properties");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        filter: [, input.filter],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_f]: [, input[_f]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1715,27 +1331,20 @@ const se_ListAssetPropertiesCommand = 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_ListAssetPropertiesCommand = se_ListAssetPropertiesCommand;
 const se_ListAssetRelationshipsCommand = 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 || ""}` + "/assets/{assetId}/assetRelationships";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/assetRelationships");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = (0, smithy_client_1.map)({
-        traversalType: [, (0, smithy_client_1.expectNonNull)(input.traversalType, `traversalType`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_tT]: [, (0, smithy_client_1.expectNonNull)(input[_tT], `traversalType`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1745,27 +1354,20 @@ const se_ListAssetRelationshipsCommand = 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_ListAssetRelationshipsCommand = se_ListAssetRelationshipsCommand;
 const se_ListAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets";
+    b.bp("/assets");
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        assetModelId: [, input.assetModelId],
-        filter: [, input.filter],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_aMI]: [, input[_aMI]],
+        [_f]: [, input[_f]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1775,28 +1377,21 @@ const se_ListAssetsCommand = 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_ListAssetsCommand = se_ListAssetsCommand;
 const se_ListAssociatedAssetsCommand = 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 || ""}` + "/assets/{assetId}/hierarchies";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/hierarchies");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = (0, smithy_client_1.map)({
-        hierarchyId: [, input.hierarchyId],
-        traversalDirection: [, input.traversalDirection],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_hI]: [, input[_hI]],
+        [_tD]: [, input[_tD]],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1806,26 +1401,19 @@ const se_ListAssociatedAssetsCommand = 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_ListAssociatedAssetsCommand = se_ListAssociatedAssetsCommand;
 const se_ListBulkImportJobsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs";
+    b.bp("/jobs");
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        filter: [, input.filter],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_f]: [, input[_f]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1835,27 +1423,19 @@ const se_ListBulkImportJobsCommand = 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_ListBulkImportJobsCommand = se_ListBulkImportJobsCommand;
 const se_ListCompositionRelationshipsCommand = 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 || ""}` +
-        "/asset-models/{assetModelId}/composition-relationships";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composition-relationships");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1865,26 +1445,19 @@ const se_ListCompositionRelationshipsCommand = 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_ListCompositionRelationshipsCommand = se_ListCompositionRelationshipsCommand;
 const se_ListDashboardsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/dashboards";
+    b.bp("/dashboards");
     const query = (0, smithy_client_1.map)({
-        projectId: [, (0, smithy_client_1.expectNonNull)(input.projectId, `projectId`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_pIr]: [, (0, smithy_client_1.expectNonNull)(input[_pIr], `projectId`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1894,25 +1467,18 @@ const se_ListDashboardsCommand = 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_ListDashboardsCommand = se_ListDashboardsCommand;
 const se_ListGatewaysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/20200301/gateways";
+    b.bp("/20200301/gateways");
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1922,25 +1488,18 @@ const se_ListGatewaysCommand = 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_ListGatewaysCommand = se_ListGatewaysCommand;
 const se_ListPortalsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals";
+    b.bp("/portals");
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1950,26 +1509,19 @@ const se_ListPortalsCommand = 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_ListPortalsCommand = se_ListPortalsCommand;
 const se_ListProjectAssetsCommand = 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 || ""}` + "/projects/{projectId}/assets";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}/assets");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1979,26 +1531,19 @@ const se_ListProjectAssetsCommand = 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_ListProjectAssetsCommand = se_ListProjectAssetsCommand;
 const se_ListProjectsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects";
+    b.bp("/projects");
     const query = (0, smithy_client_1.map)({
-        portalId: [, (0, smithy_client_1.expectNonNull)(input.portalId, `portalId`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_pIo]: [, (0, smithy_client_1.expectNonNull)(input[_pIo], `portalId`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -2008,24 +1553,17 @@ const se_ListProjectsCommand = 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_ListProjectsCommand = se_ListProjectsCommand;
 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 = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = (0, smithy_client_1.map)({
-        resourceArn: [, (0, smithy_client_1.expectNonNull)(input.resourceArn, `resourceArn`)],
+        [_rA]: [, (0, smithy_client_1.expectNonNull)(input[_rA], `resourceArn`)],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -2035,28 +1573,21 @@ 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,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
 const se_ListTimeSeriesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/timeseries";
+    b.bp("/timeseries");
     const query = (0, smithy_client_1.map)({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        assetId: [, input.assetId],
-        aliasPrefix: [, input.aliasPrefix],
-        timeSeriesType: [, input.timeSeriesType],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_aI]: [, input[_aI]],
+        [_aP]: [, input[_aP]],
+        [_tST]: [, input[_tST]],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -2066,24 +1597,17 @@ const se_ListTimeSeriesCommand = 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_ListTimeSeriesCommand = se_ListTimeSeriesCommand;
 const se_PutDefaultEncryptionConfigurationCommand = 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 || ""}` + "/configuration/account/encryption";
+    b.bp("/configuration/account/encryption");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         encryptionType: [],
@@ -2096,23 +1620,17 @@ const se_PutDefaultEncryptionConfigurationCommand = 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_PutDefaultEncryptionConfigurationCommand = se_PutDefaultEncryptionConfigurationCommand;
 const se_PutLoggingOptionsCommand = 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 || ""}` + "/logging";
+    b.bp("/logging");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         loggingOptions: (_) => (0, smithy_client_1._json)(_),
@@ -2124,23 +1642,17 @@ const se_PutLoggingOptionsCommand = 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_PutLoggingOptionsCommand = se_PutLoggingOptionsCommand;
 const se_PutStorageConfigurationCommand = 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 || ""}` + "/configuration/account/storage";
+    b.bp("/configuration/account/storage");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         disassociatedDataStorage: [],
@@ -2157,25 +1669,19 @@ const se_PutStorageConfigurationCommand = 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_PutStorageConfigurationCommand = se_PutStorageConfigurationCommand;
 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",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = (0, smithy_client_1.map)({
-        resourceArn: [, (0, smithy_client_1.expectNonNull)(input.resourceArn, `resourceArn`)],
+        [_rA]: [, (0, smithy_client_1.expectNonNull)(input[_rA], `resourceArn`)],
     });
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
@@ -2188,27 +1694,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,
-        query,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).q(query).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 = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = (0, smithy_client_1.map)({
-        resourceArn: [, (0, smithy_client_1.expectNonNull)(input.resourceArn, `resourceArn`)],
-        tagKeys: [
+        [_rA]: [, (0, smithy_client_1.expectNonNull)(input[_rA], `resourceArn`)],
+        [_tK]: [
             (0, smithy_client_1.expectNonNull)(input.tagKeys, `tagKeys`) != null,
-            () => (input.tagKeys || []).map((_entry) => _entry),
+            () => (input[_tK] || []).map((_entry) => _entry),
         ],
     });
     let body;
@@ -2219,25 +1718,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_UpdateAccessPolicyCommand = 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 || ""}` + "/access-policies/{accessPolicyId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
+    b.bp("/access-policies/{accessPolicyId}");
+    b.p("accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         accessPolicyIdentity: (_) => (0, smithy_client_1._json)(_),
@@ -2252,24 +1744,18 @@ const se_UpdateAccessPolicyCommand = 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_UpdateAccessPolicyCommand = se_UpdateAccessPolicyCommand;
 const se_UpdateAssetCommand = 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 || ""}` + "/assets/{assetId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetDescription: [],
@@ -2284,24 +1770,18 @@ const se_UpdateAssetCommand = 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_UpdateAssetCommand = se_UpdateAssetCommand;
 const se_UpdateAssetModelCommand = 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 || ""}` + "/asset-models/{assetModelId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetModelCompositeModels: (_) => se_AssetModelCompositeModels(_, context),
@@ -2319,26 +1799,19 @@ const se_UpdateAssetModelCommand = 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_UpdateAssetModelCommand = se_UpdateAssetModelCommand;
 const se_UpdateAssetModelCompositeModelCommand = 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 || ""}` +
-        "/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetModelCompositeModelId", () => input.assetModelCompositeModelId, "{assetModelCompositeModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.p("assetModelCompositeModelId", () => input.assetModelCompositeModelId, "{assetModelCompositeModelId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         assetModelCompositeModelDescription: [],
@@ -2354,25 +1827,19 @@ const se_UpdateAssetModelCompositeModelCommand = 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_UpdateAssetModelCompositeModelCommand = se_UpdateAssetModelCompositeModelCommand;
 const se_UpdateAssetPropertyCommand = 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 || ""}` + "/assets/{assetId}/properties/{propertyId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "propertyId", () => input.propertyId, "{propertyId}", false);
+    b.bp("/assets/{assetId}/properties/{propertyId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
+    b.p("propertyId", () => input.propertyId, "{propertyId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -2387,24 +1854,18 @@ const se_UpdateAssetPropertyCommand = 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_UpdateAssetPropertyCommand = se_UpdateAssetPropertyCommand;
 const se_UpdateDashboardCommand = 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 || ""}` + "/dashboards/{dashboardId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "dashboardId", () => input.dashboardId, "{dashboardId}", false);
+    b.bp("/dashboards/{dashboardId}");
+    b.p("dashboardId", () => input.dashboardId, "{dashboardId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -2419,24 +1880,18 @@ const se_UpdateDashboardCommand = 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_UpdateDashboardCommand = se_UpdateDashboardCommand;
 const se_UpdateGatewayCommand = 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 || ""}` + "/20200301/gateways/{gatewayId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayId", () => input.gatewayId, "{gatewayId}", false);
+    b.bp("/20200301/gateways/{gatewayId}");
+    b.p("gatewayId", () => input.gatewayId, "{gatewayId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         gatewayName: [],
@@ -2448,24 +1903,18 @@ const se_UpdateGatewayCommand = 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_UpdateGatewayCommand = se_UpdateGatewayCommand;
 const se_UpdateGatewayCapabilityConfigurationCommand = 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 || ""}` + "/20200301/gateways/{gatewayId}/capability";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "gatewayId", () => input.gatewayId, "{gatewayId}", false);
+    b.bp("/20200301/gateways/{gatewayId}/capability");
+    b.p("gatewayId", () => input.gatewayId, "{gatewayId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         capabilityConfiguration: [],
@@ -2478,24 +1927,18 @@ const se_UpdateGatewayCapabilityConfigurationCommand = 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_UpdateGatewayCapabilityConfigurationCommand = se_UpdateGatewayCapabilityConfigurationCommand;
 const se_UpdatePortalCommand = 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 || ""}` + "/portals/{portalId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "portalId", () => input.portalId, "{portalId}", false);
+    b.bp("/portals/{portalId}");
+    b.p("portalId", () => input.portalId, "{portalId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         alarms: (_) => (0, smithy_client_1._json)(_),
@@ -2514,24 +1957,18 @@ const se_UpdatePortalCommand = 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_UpdatePortalCommand = se_UpdatePortalCommand;
 const se_UpdateProjectCommand = 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 || ""}` + "/projects/{projectId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         clientToken: [true, (_) => _ ?? (0, uuid_1.v4)()],
@@ -2545,15 +1982,9 @@ const se_UpdateProjectCommand = 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_UpdateProjectCommand = se_UpdateProjectCommand;
 const de_AssociateAssetsCommand = async (output, context) => {
@@ -7138,6 +6569,47 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _a = "alias";
+const _aI = "assetId";
+const _aMI = "assetModelId";
+const _aMT = "assetModelTypes";
+const _aP = "aliasPrefix";
+const _aT = "aggregateTypes";
+const _cT = "clientToken";
+const _eD = "endDate";
+const _eP = "excludeProperties";
+const _eTIS = "endTimeInSeconds";
+const _eTOIN = "endTimeOffsetInNanos";
+const _f = "filter";
+const _hI = "hierarchyId";
+const _iA = "iamArn";
+const _iI = "identityId";
+const _iIS = "intervalInSeconds";
+const _iT = "identityType";
+const _iWIS = "intervalWindowInSeconds";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _pA = "propertyAlias";
+const _pI = "propertyId";
+const _pIo = "portalId";
+const _pIr = "projectId";
+const _q = "qualities";
+const _qu = "quality";
+const _r = "resolution";
+const _rA = "resourceArn";
+const _rI = "resourceId";
+const _rT = "resourceType";
+const _sD = "startDate";
+const _sTIS = "startTimeInSeconds";
+const _sTOIN = "startTimeOffsetInNanos";
+const _t = "type";
+const _tD = "traversalDirection";
+const _tK = "tagKeys";
+const _tO = "timeOrdering";
+const _tRI = "targetResourceId";
+const _tRT = "targetResourceType";
+const _tST = "timeSeriesType";
+const _tT = "traversalType";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);