@aws-sdk/client-iotsitewise 3.474.0 → 3.477.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,16 +1,17 @@
-import { HttpRequest as __HttpRequest, isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
+import { requestBuilder as rb } from "@smithy/core";
+import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { IoTSiteWiseServiceException as __BaseException } from "../models/IoTSiteWiseServiceException";
 import { AccessDeniedException, ConflictingOperationException, InternalFailureException, InvalidRequestException, LimitExceededException, QueryTimeoutException, ResourceAlreadyExistsException, ResourceNotFoundException, ServiceUnavailableException, ThrottlingException, UnauthorizedException, ValidationException, } from "../models/models_0";
 import { TooManyTagsException } from "../models/models_1";
 export const se_AssociateAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}/associate";
-    resolvedPath = __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(take(input, {
         childAssetId: [],
@@ -24,26 +25,20 @@ export const se_AssociateAssetsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_AssociateTimeSeriesToAssetPropertyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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 = map({
-        alias: [, __expectNonNull(input.alias, `alias`)],
-        assetId: [, __expectNonNull(input.assetId, `assetId`)],
-        propertyId: [, __expectNonNull(input.propertyId, `propertyId`)],
+        [_a]: [, __expectNonNull(input[_a], `alias`)],
+        [_aI]: [, __expectNonNull(input[_aI], `assetId`)],
+        [_pI]: [, __expectNonNull(input[_pI], `propertyId`)],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -56,24 +51,17 @@ export const se_AssociateTimeSeriesToAssetPropertyCommand = async (input, contex
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_BatchAssociateProjectAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{projectId}/assets/associate";
-    resolvedPath = __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(take(input, {
         assetIds: (_) => _json(_),
@@ -86,23 +74,17 @@ export const se_BatchAssociateProjectAssetsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_BatchDisassociateProjectAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{projectId}/assets/disassociate";
-    resolvedPath = __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(take(input, {
         assetIds: (_) => _json(_),
@@ -115,22 +97,16 @@ export const se_BatchDisassociateProjectAssetsCommand = async (input, context) =
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_BatchGetAssetPropertyAggregatesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         entries: (_) => se_BatchGetAssetPropertyAggregatesEntries(_, context),
@@ -144,22 +120,16 @@ export const se_BatchGetAssetPropertyAggregatesCommand = async (input, context)
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_BatchGetAssetPropertyValueCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         entries: (_) => _json(_),
@@ -172,22 +142,16 @@ export const se_BatchGetAssetPropertyValueCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_BatchGetAssetPropertyValueHistoryCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         entries: (_) => se_BatchGetAssetPropertyValueHistoryEntries(_, context),
@@ -201,22 +165,16 @@ export const se_BatchGetAssetPropertyValueHistoryCommand = async (input, context
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_BatchPutAssetPropertyValueCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         entries: (_) => se_PutAssetPropertyValueEntries(_, context),
@@ -228,22 +186,16 @@ export const se_BatchPutAssetPropertyValueCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateAccessPolicyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         accessPolicyIdentity: (_) => _json(_),
@@ -259,22 +211,16 @@ export const se_CreateAccessPolicyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateAssetCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         assetDescription: [],
@@ -292,22 +238,16 @@ export const se_CreateAssetCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateAssetModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         assetModelCompositeModels: (_) => se_AssetModelCompositeModelDefinitions(_, context),
@@ -328,24 +268,17 @@ export const se_CreateAssetModelCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateAssetModelCompositeModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/asset-models/{assetModelId}/composite-models";
-    resolvedPath = __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(take(input, {
         assetModelCompositeModelDescription: [],
@@ -365,22 +298,16 @@ export const se_CreateAssetModelCompositeModelCommand = async (input, context) =
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateBulkImportJobCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         adaptiveIngestion: [],
@@ -398,22 +325,16 @@ export const se_CreateBulkImportJobCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateDashboardCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -430,22 +351,16 @@ export const se_CreateDashboardCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateGatewayCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         gatewayName: [],
@@ -459,22 +374,16 @@ export const se_CreateGatewayCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreatePortalCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         alarms: (_) => _json(_),
@@ -495,22 +404,16 @@ export const se_CreatePortalCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateProjectCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -526,23 +429,17 @@ export const se_CreateProjectCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteAccessPolicyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/access-policies/{accessPolicyId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
+    b.bp("/access-policies/{accessPolicyId}");
+    b.p("accessPolicyId", () => input.accessPolicyId, "{accessPolicyId}", false);
     const query = map({
-        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -552,24 +449,17 @@ export const se_DeleteAccessPolicyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DeleteAssetCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = map({
-        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -579,24 +469,17 @@ export const se_DeleteAssetCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DeleteAssetModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/asset-models/{assetModelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = map({
-        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -606,26 +489,18 @@ export const se_DeleteAssetModelCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DeleteAssetModelCompositeModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
-    resolvedPath = __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 = map({
-        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -635,24 +510,17 @@ export const se_DeleteAssetModelCompositeModelCommand = async (input, context) =
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DeleteDashboardCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/dashboards/{dashboardId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "dashboardId", () => input.dashboardId, "{dashboardId}", false);
+    b.bp("/dashboards/{dashboardId}");
+    b.p("dashboardId", () => input.dashboardId, "{dashboardId}", false);
     const query = map({
-        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -662,22 +530,15 @@ export const se_DeleteDashboardCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DeleteGatewayCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/20200301/gateways/{gatewayId}";
-    resolvedPath = __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) {
@@ -686,23 +547,17 @@ export const se_DeleteGatewayCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeletePortalCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "portalId", () => input.portalId, "{portalId}", false);
+    b.bp("/portals/{portalId}");
+    b.p("portalId", () => input.portalId, "{portalId}", false);
     const query = map({
-        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -712,24 +567,17 @@ export const se_DeletePortalCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DeleteProjectCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{projectId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     const query = map({
-        clientToken: [, input.clientToken ?? generateIdempotencyToken()],
+        [_cT]: [, input[_cT] ?? generateIdempotencyToken()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -739,27 +587,20 @@ export const se_DeleteProjectCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DeleteTimeSeriesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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 = map({
-        alias: [, input.alias],
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
+        [_a]: [, input[_a]],
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -772,22 +613,15 @@ export const se_DeleteTimeSeriesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DescribeAccessPolicyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/access-policies/{accessPolicyId}";
-    resolvedPath = __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) {
@@ -796,21 +630,15 @@ export const se_DescribeAccessPolicyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeActionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actions/{actionId}";
-    resolvedPath = __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) {
@@ -819,23 +647,17 @@ export const se_DescribeActionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeAssetCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = 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();
@@ -845,24 +667,16 @@ export const se_DescribeAssetCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DescribeAssetCompositeModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/assets/{assetId}/composite-models/{assetCompositeModelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
-    resolvedPath = __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) {
@@ -871,23 +685,17 @@ export const se_DescribeAssetCompositeModelCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeAssetModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/asset-models/{assetModelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = 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();
@@ -897,24 +705,16 @@ export const se_DescribeAssetModelCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DescribeAssetModelCompositeModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
-    resolvedPath = __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) {
@@ -923,22 +723,16 @@ export const se_DescribeAssetModelCompositeModelCommand = async (input, context)
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeAssetPropertyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}/properties/{propertyId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
-    resolvedPath = __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) {
@@ -947,21 +741,15 @@ export const se_DescribeAssetPropertyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeBulkImportJobCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs/{jobId}";
-    resolvedPath = __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) {
@@ -970,21 +758,15 @@ export const se_DescribeBulkImportJobCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeDashboardCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/dashboards/{dashboardId}";
-    resolvedPath = __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) {
@@ -993,22 +775,16 @@ export const se_DescribeDashboardCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeDefaultEncryptionConfigurationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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();
@@ -1018,21 +794,15 @@ export const se_DescribeDefaultEncryptionConfigurationCommand = async (input, co
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeGatewayCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/20200301/gateways/{gatewayId}";
-    resolvedPath = __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) {
@@ -1041,23 +811,16 @@ export const se_DescribeGatewayCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeGatewayCapabilityConfigurationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/20200301/gateways/{gatewayId}/capability/{capabilityNamespace}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "gatewayId", () => input.gatewayId, "{gatewayId}", false);
-    resolvedPath = __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) {
@@ -1066,22 +829,16 @@ export const se_DescribeGatewayCapabilityConfigurationCommand = async (input, co
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeLoggingOptionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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();
@@ -1091,21 +848,15 @@ export const se_DescribeLoggingOptionsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribePortalCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalId}";
-    resolvedPath = __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) {
@@ -1114,21 +865,15 @@ export const se_DescribePortalCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeProjectCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{projectId}";
-    resolvedPath = __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) {
@@ -1137,22 +882,16 @@ export const se_DescribeProjectCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeStorageConfigurationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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();
@@ -1162,24 +901,18 @@ export const se_DescribeStorageConfigurationCommand = async (input, context) =>
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_DescribeTimeSeriesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/timeseries/describe";
+    b.bp("/timeseries/describe");
     const query = 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();
@@ -1189,24 +922,17 @@ export const se_DescribeTimeSeriesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_DisassociateAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}/disassociate";
-    resolvedPath = __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(take(input, {
         childAssetId: [],
@@ -1220,26 +946,20 @@ export const se_DisassociateAssetsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_DisassociateTimeSeriesFromAssetPropertyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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 = map({
-        alias: [, __expectNonNull(input.alias, `alias`)],
-        assetId: [, __expectNonNull(input.assetId, `assetId`)],
-        propertyId: [, __expectNonNull(input.propertyId, `propertyId`)],
+        [_a]: [, __expectNonNull(input[_a], `alias`)],
+        [_aI]: [, __expectNonNull(input[_aI], `assetId`)],
+        [_pI]: [, __expectNonNull(input[_pI], `propertyId`)],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -1252,23 +972,16 @@ export const se_DisassociateTimeSeriesFromAssetPropertyCommand = async (input, c
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ExecuteActionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         actionDefinitionId: [],
@@ -1283,22 +996,16 @@ export const se_ExecuteActionCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_ExecuteQueryCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         maxResults: [],
@@ -1312,41 +1019,35 @@ export const se_ExecuteQueryCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_GetAssetPropertyAggregatesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/aggregates";
+    b.bp("/properties/aggregates");
     const query = map({
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
-        propertyAlias: [, input.propertyAlias],
-        aggregateTypes: [
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
+        [_pA]: [, input[_pA]],
+        [_aT]: [
             __expectNonNull(input.aggregateTypes, `aggregateTypes`) != null,
-            () => (input.aggregateTypes || []).map((_entry) => _entry),
+            () => (input[_aT] || []).map((_entry) => _entry),
         ],
-        resolution: [, __expectNonNull(input.resolution, `resolution`)],
-        qualities: [() => input.qualities !== void 0, () => (input.qualities || []).map((_entry) => _entry)],
-        startDate: [
+        [_r]: [, __expectNonNull(input[_r], `resolution`)],
+        [_q]: [() => input.qualities !== void 0, () => (input[_q] || []).map((_entry) => _entry)],
+        [_sD]: [
             __expectNonNull(input.startDate, `startDate`) != null,
-            () => (input.startDate.toISOString().split(".")[0] + "Z").toString(),
+            () => (input[_sD].toISOString().split(".")[0] + "Z").toString(),
         ],
-        endDate: [
+        [_eD]: [
             __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();
@@ -1356,25 +1057,18 @@ export const se_GetAssetPropertyAggregatesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_GetAssetPropertyValueCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/latest";
+    b.bp("/properties/latest");
     const query = 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();
@@ -1384,34 +1078,24 @@ export const se_GetAssetPropertyValueCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_GetAssetPropertyValueHistoryCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/history";
+    b.bp("/properties/history");
     const query = 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();
@@ -1421,50 +1105,28 @@ export const se_GetAssetPropertyValueHistoryCommand = async (input, context) =>
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_GetInterpolatedAssetPropertyValuesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/properties/interpolated";
+    b.bp("/properties/interpolated");
     const query = map({
-        assetId: [, input.assetId],
-        propertyId: [, input.propertyId],
-        propertyAlias: [, input.propertyAlias],
-        startTimeInSeconds: [
-            __expectNonNull(input.startTimeInSeconds, `startTimeInSeconds`) != null,
-            () => input.startTimeInSeconds.toString(),
-        ],
-        startTimeOffsetInNanos: [
-            () => input.startTimeOffsetInNanos !== void 0,
-            () => input.startTimeOffsetInNanos.toString(),
-        ],
-        endTimeInSeconds: [
-            __expectNonNull(input.endTimeInSeconds, `endTimeInSeconds`) != null,
-            () => input.endTimeInSeconds.toString(),
-        ],
-        endTimeOffsetInNanos: [() => input.endTimeOffsetInNanos !== void 0, () => input.endTimeOffsetInNanos.toString()],
-        quality: [, __expectNonNull(input.quality, `quality`)],
-        intervalInSeconds: [
-            __expectNonNull(input.intervalInSeconds, `intervalInSeconds`) != null,
-            () => input.intervalInSeconds.toString(),
-        ],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        type: [, __expectNonNull(input.type, `type`)],
-        intervalWindowInSeconds: [
-            () => input.intervalWindowInSeconds !== void 0,
-            () => input.intervalWindowInSeconds.toString(),
-        ],
+        [_aI]: [, input[_aI]],
+        [_pI]: [, input[_pI]],
+        [_pA]: [, input[_pA]],
+        [_sTIS]: [__expectNonNull(input.startTimeInSeconds, `startTimeInSeconds`) != null, () => input[_sTIS].toString()],
+        [_sTOIN]: [() => input.startTimeOffsetInNanos !== void 0, () => input[_sTOIN].toString()],
+        [_eTIS]: [__expectNonNull(input.endTimeInSeconds, `endTimeInSeconds`) != null, () => input[_eTIS].toString()],
+        [_eTOIN]: [() => input.endTimeOffsetInNanos !== void 0, () => input[_eTOIN].toString()],
+        [_qu]: [, __expectNonNull(input[_qu], `quality`)],
+        [_iIS]: [__expectNonNull(input.intervalInSeconds, `intervalInSeconds`) != null, () => input[_iIS].toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_t]: [, __expectNonNull(input[_t], `type`)],
+        [_iWIS]: [() => input.intervalWindowInSeconds !== void 0, () => input[_iWIS].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1474,29 +1136,22 @@ export const se_GetInterpolatedAssetPropertyValuesCommand = async (input, contex
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAccessPoliciesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/access-policies";
+    b.bp("/access-policies");
     const query = 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();
@@ -1506,26 +1161,19 @@ export const se_ListAccessPoliciesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListActionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/actions";
+    b.bp("/actions");
     const query = map({
-        targetResourceType: [, __expectNonNull(input.targetResourceType, `targetResourceType`)],
-        targetResourceId: [, __expectNonNull(input.targetResourceId, `targetResourceId`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_tRT]: [, __expectNonNull(input[_tRT], `targetResourceType`)],
+        [_tRI]: [, __expectNonNull(input[_tRI], `targetResourceId`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1535,26 +1183,18 @@ export const se_ListActionsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAssetModelCompositeModelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/asset-models/{assetModelId}/composite-models";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composite-models");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = 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();
@@ -1564,26 +1204,19 @@ export const se_ListAssetModelCompositeModelsCommand = async (input, context) =>
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAssetModelPropertiesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/asset-models/{assetModelId}/properties";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}/properties");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = 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();
@@ -1593,28 +1226,18 @@ export const se_ListAssetModelPropertiesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAssetModelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/asset-models";
+    b.bp("/asset-models");
     const query = 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();
@@ -1624,26 +1247,19 @@ export const se_ListAssetModelsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAssetPropertiesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}/properties";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/properties");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = 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,26 +1269,19 @@ export const se_ListAssetPropertiesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAssetRelationshipsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}/assetRelationships";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/assetRelationships");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = map({
-        traversalType: [, __expectNonNull(input.traversalType, `traversalType`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_tT]: [, __expectNonNull(input[_tT], `traversalType`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1682,26 +1291,19 @@ export const se_ListAssetRelationshipsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets";
+    b.bp("/assets");
     const query = 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();
@@ -1711,27 +1313,20 @@ export const se_ListAssetsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListAssociatedAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}/hierarchies";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}/hierarchies");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     const query = 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();
@@ -1741,25 +1336,18 @@ export const se_ListAssociatedAssetsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListBulkImportJobsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/jobs";
+    b.bp("/jobs");
     const query = 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();
@@ -1769,26 +1357,18 @@ export const se_ListBulkImportJobsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListCompositionRelationshipsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/asset-models/{assetModelId}/composition-relationships";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
+    b.bp("/asset-models/{assetModelId}/composition-relationships");
+    b.p("assetModelId", () => input.assetModelId, "{assetModelId}", false);
     const query = 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();
@@ -1798,25 +1378,18 @@ export const se_ListCompositionRelationshipsCommand = async (input, context) =>
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListDashboardsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/dashboards";
+    b.bp("/dashboards");
     const query = map({
-        projectId: [, __expectNonNull(input.projectId, `projectId`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_pIr]: [, __expectNonNull(input[_pIr], `projectId`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1826,24 +1399,17 @@ export const se_ListDashboardsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListGatewaysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/20200301/gateways";
+    b.bp("/20200301/gateways");
     const query = 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();
@@ -1853,24 +1419,17 @@ export const se_ListGatewaysCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListPortalsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals";
+    b.bp("/portals");
     const query = 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();
@@ -1880,25 +1439,18 @@ export const se_ListPortalsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListProjectAssetsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{projectId}/assets";
-    resolvedPath = __resolvedPath(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}/assets");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     const query = 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();
@@ -1908,25 +1460,18 @@ export const se_ListProjectAssetsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListProjectsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects";
+    b.bp("/projects");
     const query = map({
-        portalId: [, __expectNonNull(input.portalId, `portalId`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_pIo]: [, __expectNonNull(input[_pIo], `portalId`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1936,23 +1481,16 @@ export const se_ListProjectsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListTagsForResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
+        [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
     });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -1962,27 +1500,20 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_ListTimeSeriesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/timeseries";
+    b.bp("/timeseries");
     const query = 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();
@@ -1992,23 +1523,16 @@ export const se_ListTimeSeriesCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_PutDefaultEncryptionConfigurationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         encryptionType: [],
@@ -2021,22 +1545,16 @@ export const se_PutDefaultEncryptionConfigurationCommand = async (input, context
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_PutLoggingOptionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         loggingOptions: (_) => _json(_),
@@ -2048,22 +1566,16 @@ export const se_PutLoggingOptionsCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutStorageConfigurationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(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(take(input, {
         disassociatedDataStorage: [],
@@ -2080,24 +1592,18 @@ export const se_PutStorageConfigurationCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_TagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
+        [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -2110,26 +1616,19 @@ export const se_TagResourceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_UntagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        resourceArn: [, __expectNonNull(input.resourceArn, `resourceArn`)],
-        tagKeys: [
+        [_rA]: [, __expectNonNull(input[_rA], `resourceArn`)],
+        [_tK]: [
             __expectNonNull(input.tagKeys, `tagKeys`) != null,
-            () => (input.tagKeys || []).map((_entry) => _entry),
+            () => (input[_tK] || []).map((_entry) => _entry),
         ],
     });
     let body;
@@ -2140,24 +1639,17 @@ export const se_UntagResourceCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __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();
 };
 export const se_UpdateAccessPolicyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/access-policies/{accessPolicyId}";
-    resolvedPath = __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(take(input, {
         accessPolicyIdentity: (_) => _json(_),
@@ -2172,23 +1664,17 @@ export const se_UpdateAccessPolicyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateAssetCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
+    b.bp("/assets/{assetId}");
+    b.p("assetId", () => input.assetId, "{assetId}", false);
     let body;
     body = JSON.stringify(take(input, {
         assetDescription: [],
@@ -2203,23 +1689,17 @@ export const se_UpdateAssetCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateAssetModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/asset-models/{assetModelId}";
-    resolvedPath = __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(take(input, {
         assetModelCompositeModels: (_) => se_AssetModelCompositeModels(_, context),
@@ -2237,25 +1717,18 @@ export const se_UpdateAssetModelCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateAssetModelCompositeModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/asset-models/{assetModelId}/composite-models/{assetModelCompositeModelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetModelId", () => input.assetModelId, "{assetModelId}", false);
-    resolvedPath = __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(take(input, {
         assetModelCompositeModelDescription: [],
@@ -2271,24 +1744,18 @@ export const se_UpdateAssetModelCompositeModelCommand = async (input, context) =
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateAssetPropertyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/assets/{assetId}/properties/{propertyId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "assetId", () => input.assetId, "{assetId}", false);
-    resolvedPath = __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(take(input, {
         clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -2303,23 +1770,17 @@ export const se_UpdateAssetPropertyCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateDashboardCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/dashboards/{dashboardId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "dashboardId", () => input.dashboardId, "{dashboardId}", false);
+    b.bp("/dashboards/{dashboardId}");
+    b.p("dashboardId", () => input.dashboardId, "{dashboardId}", false);
     let body;
     body = JSON.stringify(take(input, {
         clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -2334,23 +1795,17 @@ export const se_UpdateDashboardCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateGatewayCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/20200301/gateways/{gatewayId}";
-    resolvedPath = __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(take(input, {
         gatewayName: [],
@@ -2362,23 +1817,17 @@ export const se_UpdateGatewayCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateGatewayCapabilityConfigurationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/20200301/gateways/{gatewayId}/capability";
-    resolvedPath = __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(take(input, {
         capabilityConfiguration: [],
@@ -2391,23 +1840,17 @@ export const se_UpdateGatewayCapabilityConfigurationCommand = async (input, cont
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdatePortalCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/portals/{portalId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "portalId", () => input.portalId, "{portalId}", false);
+    b.bp("/portals/{portalId}");
+    b.p("portalId", () => input.portalId, "{portalId}", false);
     let body;
     body = JSON.stringify(take(input, {
         alarms: (_) => _json(_),
@@ -2426,23 +1869,17 @@ export const se_UpdatePortalCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateProjectCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/projects/{projectId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "projectId", () => input.projectId, "{projectId}", false);
+    b.bp("/projects/{projectId}");
+    b.p("projectId", () => input.projectId, "{projectId}", false);
     let body;
     body = JSON.stringify(take(input, {
         clientToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -2456,15 +1893,9 @@ export const se_UpdateProjectCommand = async (input, context) => {
             throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
         }
     }
-    return new __HttpRequest({
-        protocol,
-        hostname: resolvedHostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const de_AssociateAssetsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -6964,6 +6395,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);