@aws-sdk/client-api-gateway 3.476.0 → 3.477.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -5,16 +5,16 @@ exports.se_UpdateApiKeyCommand = exports.se_UpdateAccountCommand = exports.se_Un
 exports.de_DeleteRequestValidatorCommand = exports.de_DeleteModelCommand = exports.de_DeleteMethodResponseCommand = exports.de_DeleteMethodCommand = exports.de_DeleteIntegrationResponseCommand = exports.de_DeleteIntegrationCommand = exports.de_DeleteGatewayResponseCommand = exports.de_DeleteDomainNameCommand = exports.de_DeleteDocumentationVersionCommand = exports.de_DeleteDocumentationPartCommand = exports.de_DeleteDeploymentCommand = exports.de_DeleteClientCertificateCommand = exports.de_DeleteBasePathMappingCommand = exports.de_DeleteAuthorizerCommand = exports.de_DeleteApiKeyCommand = exports.de_CreateVpcLinkCommand = exports.de_CreateUsagePlanKeyCommand = exports.de_CreateUsagePlanCommand = exports.de_CreateStageCommand = exports.de_CreateRestApiCommand = exports.de_CreateResourceCommand = exports.de_CreateRequestValidatorCommand = exports.de_CreateModelCommand = exports.de_CreateDomainNameCommand = exports.de_CreateDocumentationVersionCommand = exports.de_CreateDocumentationPartCommand = exports.de_CreateDeploymentCommand = exports.de_CreateBasePathMappingCommand = exports.de_CreateAuthorizerCommand = exports.de_CreateApiKeyCommand = exports.se_UpdateVpcLinkCommand = exports.se_UpdateUsagePlanCommand = exports.se_UpdateUsageCommand = exports.se_UpdateStageCommand = exports.se_UpdateRestApiCommand = exports.se_UpdateResourceCommand = exports.se_UpdateRequestValidatorCommand = exports.se_UpdateModelCommand = exports.se_UpdateMethodResponseCommand = exports.se_UpdateMethodCommand = exports.se_UpdateIntegrationResponseCommand = exports.se_UpdateIntegrationCommand = exports.se_UpdateGatewayResponseCommand = exports.se_UpdateDomainNameCommand = exports.se_UpdateDocumentationVersionCommand = exports.se_UpdateDocumentationPartCommand = exports.se_UpdateDeploymentCommand = exports.se_UpdateClientCertificateCommand = exports.se_UpdateBasePathMappingCommand = exports.se_UpdateAuthorizerCommand = void 0;
 exports.de_GetUsagePlanCommand = exports.de_GetUsageCommand = exports.de_GetTagsCommand = exports.de_GetStagesCommand = exports.de_GetStageCommand = exports.de_GetSdkTypesCommand = exports.de_GetSdkTypeCommand = exports.de_GetSdkCommand = exports.de_GetRestApisCommand = exports.de_GetRestApiCommand = exports.de_GetResourcesCommand = exports.de_GetResourceCommand = exports.de_GetRequestValidatorsCommand = exports.de_GetRequestValidatorCommand = exports.de_GetModelTemplateCommand = exports.de_GetModelsCommand = exports.de_GetModelCommand = exports.de_GetMethodResponseCommand = exports.de_GetMethodCommand = exports.de_GetIntegrationResponseCommand = exports.de_GetIntegrationCommand = exports.de_GetGatewayResponsesCommand = exports.de_GetGatewayResponseCommand = exports.de_GetExportCommand = exports.de_GetDomainNamesCommand = exports.de_GetDomainNameCommand = exports.de_GetDocumentationVersionsCommand = exports.de_GetDocumentationVersionCommand = exports.de_GetDocumentationPartsCommand = exports.de_GetDocumentationPartCommand = exports.de_GetDeploymentsCommand = exports.de_GetDeploymentCommand = exports.de_GetClientCertificatesCommand = exports.de_GetClientCertificateCommand = exports.de_GetBasePathMappingsCommand = exports.de_GetBasePathMappingCommand = exports.de_GetAuthorizersCommand = exports.de_GetAuthorizerCommand = exports.de_GetApiKeysCommand = exports.de_GetApiKeyCommand = exports.de_GetAccountCommand = exports.de_GenerateClientCertificateCommand = exports.de_FlushStageCacheCommand = exports.de_FlushStageAuthorizersCacheCommand = exports.de_DeleteVpcLinkCommand = exports.de_DeleteUsagePlanKeyCommand = exports.de_DeleteUsagePlanCommand = exports.de_DeleteStageCommand = exports.de_DeleteRestApiCommand = exports.de_DeleteResourceCommand = void 0;
 exports.de_UpdateVpcLinkCommand = exports.de_UpdateUsagePlanCommand = exports.de_UpdateUsageCommand = exports.de_UpdateStageCommand = exports.de_UpdateRestApiCommand = exports.de_UpdateResourceCommand = exports.de_UpdateRequestValidatorCommand = exports.de_UpdateModelCommand = exports.de_UpdateMethodResponseCommand = exports.de_UpdateMethodCommand = exports.de_UpdateIntegrationResponseCommand = exports.de_UpdateIntegrationCommand = exports.de_UpdateGatewayResponseCommand = exports.de_UpdateDomainNameCommand = exports.de_UpdateDocumentationVersionCommand = exports.de_UpdateDocumentationPartCommand = exports.de_UpdateDeploymentCommand = exports.de_UpdateClientCertificateCommand = exports.de_UpdateBasePathMappingCommand = exports.de_UpdateAuthorizerCommand = exports.de_UpdateApiKeyCommand = exports.de_UpdateAccountCommand = exports.de_UntagResourceCommand = exports.de_TestInvokeMethodCommand = exports.de_TestInvokeAuthorizerCommand = exports.de_TagResourceCommand = exports.de_PutRestApiCommand = exports.de_PutMethodResponseCommand = exports.de_PutMethodCommand = exports.de_PutIntegrationResponseCommand = exports.de_PutIntegrationCommand = exports.de_PutGatewayResponseCommand = exports.de_ImportRestApiCommand = exports.de_ImportDocumentationPartsCommand = exports.de_ImportApiKeysCommand = exports.de_GetVpcLinksCommand = exports.de_GetVpcLinkCommand = exports.de_GetUsagePlansCommand = exports.de_GetUsagePlanKeysCommand = exports.de_GetUsagePlanKeyCommand = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
+const core_1 = require("@smithy/core");
 const smithy_client_1 = require("@smithy/smithy-client");
 const APIGatewayServiceException_1 = require("../models/APIGatewayServiceException");
 const models_0_1 = require("../models/models_0");
 const se_CreateApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
+    b.bp("/apikeys");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         customerId: [],
@@ -26,24 +26,17 @@ const se_CreateApiKeyCommand = async (input, context) => {
         tags: (_) => (0, smithy_client_1._json)(_),
         value: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateApiKeyCommand = se_CreateApiKeyCommand;
 const se_CreateAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/authorizers";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/authorizers");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         authType: [],
@@ -56,49 +49,34 @@ const se_CreateAuthorizerCommand = async (input, context) => {
         providerARNs: (_) => (0, smithy_client_1._json)(_),
         type: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateAuthorizerCommand = se_CreateAuthorizerCommand;
 const se_CreateBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}/basepathmappings");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         basePath: [],
         restApiId: [],
         stage: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateBasePathMappingCommand = se_CreateBasePathMappingCommand;
 const se_CreateDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/deployments";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/deployments");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         cacheClusterEnabled: [],
@@ -110,71 +88,49 @@ const se_CreateDeploymentCommand = async (input, context) => {
         tracingEnabled: [],
         variables: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateDeploymentCommand = se_CreateDeploymentCommand;
 const se_CreateDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         location: (_) => (0, smithy_client_1._json)(_),
         properties: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateDocumentationPartCommand = se_CreateDocumentationPartCommand;
 const se_CreateDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/versions");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         description: [],
         documentationVersion: [],
         stageName: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateDocumentationVersionCommand = se_CreateDocumentationVersionCommand;
 const se_CreateDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames";
+    b.bp("/domainnames");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         certificateArn: [],
@@ -191,24 +147,17 @@ const se_CreateDomainNameCommand = async (input, context) => {
         securityPolicy: [],
         tags: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateDomainNameCommand = se_CreateDomainNameCommand;
 const se_CreateModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/models");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         contentType: [],
@@ -216,71 +165,49 @@ const se_CreateModelCommand = async (input, context) => {
         name: [],
         schema: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateModelCommand = se_CreateModelCommand;
 const se_CreateRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/requestvalidators";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/requestvalidators");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         name: [],
         validateRequestBody: [],
         validateRequestParameters: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateRequestValidatorCommand = se_CreateRequestValidatorCommand;
 const se_CreateResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{parentId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "parentId", () => input.parentId, "{parentId}", false);
+    b.bp("/restapis/{restApiId}/resources/{parentId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("parentId", () => input.parentId, "{parentId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         pathPart: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateResourceCommand = se_CreateResourceCommand;
 const se_CreateRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
+    b.bp("/restapis");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         apiKeySource: [],
@@ -295,24 +222,17 @@ const se_CreateRestApiCommand = async (input, context) => {
         tags: (_) => (0, smithy_client_1._json)(_),
         version: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateRestApiCommand = se_CreateRestApiCommand;
 const se_CreateStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/stages");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         cacheClusterEnabled: [],
@@ -326,23 +246,16 @@ const se_CreateStageCommand = async (input, context) => {
         tracingEnabled: [],
         variables: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateStageCommand = se_CreateStageCommand;
 const se_CreateUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans";
+    b.bp("/usageplans");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         apiStages: (_) => se_ListOfApiStage(_, context),
@@ -352,46 +265,32 @@ const se_CreateUsagePlanCommand = async (input, context) => {
         tags: (_) => (0, smithy_client_1._json)(_),
         throttle: (_) => se_ThrottleSettings(_, context),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateUsagePlanCommand = se_CreateUsagePlanCommand;
 const se_CreateUsagePlanKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}/keys");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         keyId: [],
         keyType: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateUsagePlanKeyCommand = se_CreateUsagePlanKeyCommand;
 const se_CreateVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks";
+    b.bp("/vpclinks");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         description: [],
@@ -399,1542 +298,955 @@ const se_CreateVpcLinkCommand = async (input, context) => {
         tags: (_) => (0, smithy_client_1._json)(_),
         targetArns: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_CreateVpcLinkCommand = se_CreateVpcLinkCommand;
 const se_DeleteApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
+    b.bp("/apikeys/{apiKey}");
+    b.p("apiKey", () => input.apiKey, "{apiKey}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteApiKeyCommand = se_DeleteApiKeyCommand;
 const se_DeleteAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
+    b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteAuthorizerCommand = se_DeleteAuthorizerCommand;
 const se_DeleteBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings/{basePath}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "basePath", () => input.basePath, "{basePath}", false);
+    b.bp("/domainnames/{domainName}/basepathmappings/{basePath}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
+    b.p("basePath", () => input.basePath, "{basePath}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteBasePathMappingCommand = se_DeleteBasePathMappingCommand;
 const se_DeleteClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
+    b.bp("/clientcertificates/{clientCertificateId}");
+    b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteClientCertificateCommand = se_DeleteClientCertificateCommand;
 const se_DeleteDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/deployments/{deploymentId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "deploymentId", () => input.deploymentId, "{deploymentId}", false);
+    b.bp("/restapis/{restApiId}/deployments/{deploymentId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("deploymentId", () => input.deploymentId, "{deploymentId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteDeploymentCommand = se_DeleteDeploymentCommand;
 const se_DeleteDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts/{documentationPartId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteDocumentationPartCommand = se_DeleteDocumentationPartCommand;
 const se_DeleteDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
+    b.bp("/restapis/{restApiId}/documentation/versions/{documentationVersion}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteDocumentationVersionCommand = se_DeleteDocumentationVersionCommand;
 const se_DeleteDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteDomainNameCommand = se_DeleteDomainNameCommand;
 const se_DeleteGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
+    b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("responseType", () => input.responseType, "{responseType}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteGatewayResponseCommand = se_DeleteGatewayResponseCommand;
 const se_DeleteIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteIntegrationCommand = se_DeleteIntegrationCommand;
 const se_DeleteIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteIntegrationResponseCommand = se_DeleteIntegrationResponseCommand;
 const se_DeleteMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteMethodCommand = se_DeleteMethodCommand;
 const se_DeleteMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteMethodResponseCommand = se_DeleteMethodResponseCommand;
 const se_DeleteModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
+    b.bp("/restapis/{restApiId}/models/{modelName}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("modelName", () => input.modelName, "{modelName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteModelCommand = se_DeleteModelCommand;
 const se_DeleteRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
+    b.bp("/restapis/{restApiId}/requestvalidators/{requestValidatorId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteRequestValidatorCommand = se_DeleteRequestValidatorCommand;
 const se_DeleteResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteResourceCommand = se_DeleteResourceCommand;
 const se_DeleteRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteRestApiCommand = se_DeleteRestApiCommand;
 const se_DeleteStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
+    b.bp("/restapis/{restApiId}/stages/{stageName}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("stageName", () => input.stageName, "{stageName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteStageCommand = se_DeleteStageCommand;
 const se_DeleteUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteUsagePlanCommand = se_DeleteUsagePlanCommand;
 const se_DeleteUsagePlanKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys/{keyId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "keyId", () => input.keyId, "{keyId}", false);
+    b.bp("/usageplans/{usagePlanId}/keys/{keyId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.p("keyId", () => input.keyId, "{keyId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteUsagePlanKeyCommand = se_DeleteUsagePlanKeyCommand;
 const se_DeleteVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
+    b.bp("/vpclinks/{vpcLinkId}");
+    b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_DeleteVpcLinkCommand = se_DeleteVpcLinkCommand;
 const se_FlushStageAuthorizersCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/cache/authorizers";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
+    b.bp("/restapis/{restApiId}/stages/{stageName}/cache/authorizers");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("stageName", () => input.stageName, "{stageName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_FlushStageAuthorizersCacheCommand = se_FlushStageAuthorizersCacheCommand;
 const se_FlushStageCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/cache/data";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
+    b.bp("/restapis/{restApiId}/stages/{stageName}/cache/data");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("stageName", () => input.stageName, "{stageName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 exports.se_FlushStageCacheCommand = se_FlushStageCacheCommand;
 const se_GenerateClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates";
+    b.bp("/clientcertificates");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         description: [],
         tags: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_GenerateClientCertificateCommand = se_GenerateClientCertificateCommand;
 const se_GetAccountCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account";
+    b.bp("/account");
     let body;
     body = "";
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetAccountCommand = se_GetAccountCommand;
 const se_GetApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
+    b.bp("/apikeys/{apiKey}");
+    b.p("apiKey", () => input.apiKey, "{apiKey}", false);
     const query = (0, smithy_client_1.map)({
-        includeValue: [() => input.includeValue !== void 0, () => input.includeValue.toString()],
+        [_iV]: [() => input.includeValue !== void 0, () => input[_iV].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetApiKeyCommand = se_GetApiKeyCommand;
 const se_GetApiKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
+    b.bp("/apikeys");
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
-        name: [, input.nameQuery],
-        customerId: [, input.customerId],
-        includeValues: [() => input.includeValues !== void 0, () => input.includeValues.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+        [_n]: [, input[_nQ]],
+        [_cI]: [, input[_cI]],
+        [_iVn]: [() => input.includeValues !== void 0, () => input[_iVn].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetApiKeysCommand = se_GetApiKeysCommand;
 const se_GetAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
+    b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetAuthorizerCommand = se_GetAuthorizerCommand;
 const se_GetAuthorizersCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/authorizers";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/authorizers");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetAuthorizersCommand = se_GetAuthorizersCommand;
 const se_GetBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings/{basePath}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "basePath", () => input.basePath, "{basePath}", false);
+    b.bp("/domainnames/{domainName}/basepathmappings/{basePath}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
+    b.p("basePath", () => input.basePath, "{basePath}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetBasePathMappingCommand = se_GetBasePathMappingCommand;
 const se_GetBasePathMappingsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}/basepathmappings");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetBasePathMappingsCommand = se_GetBasePathMappingsCommand;
 const se_GetClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
+    b.bp("/clientcertificates/{clientCertificateId}");
+    b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetClientCertificateCommand = se_GetClientCertificateCommand;
 const se_GetClientCertificatesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates";
+    b.bp("/clientcertificates");
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetClientCertificatesCommand = se_GetClientCertificatesCommand;
 const se_GetDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/deployments/{deploymentId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "deploymentId", () => input.deploymentId, "{deploymentId}", false);
+    b.bp("/restapis/{restApiId}/deployments/{deploymentId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("deploymentId", () => input.deploymentId, "{deploymentId}", false);
     const query = (0, smithy_client_1.map)({
-        embed: [() => input.embed !== void 0, () => (input.embed || []).map((_entry) => _entry)],
+        [_e]: [() => input.embed !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetDeploymentCommand = se_GetDeploymentCommand;
 const se_GetDeploymentsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/deployments";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/deployments");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetDeploymentsCommand = se_GetDeploymentsCommand;
 const se_GetDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts/{documentationPartId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetDocumentationPartCommand = se_GetDocumentationPartCommand;
 const se_GetDocumentationPartsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        type: [, input.type],
-        name: [, input.nameQuery],
-        path: [, input.path],
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
-        locationStatus: [, input.locationStatus],
+        [_t]: [, input[_t]],
+        [_n]: [, input[_nQ]],
+        [_pa]: [, input[_pa]],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+        [_lS]: [, input[_lS]],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetDocumentationPartsCommand = se_GetDocumentationPartsCommand;
 const se_GetDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
+    b.bp("/restapis/{restApiId}/documentation/versions/{documentationVersion}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetDocumentationVersionCommand = se_GetDocumentationVersionCommand;
 const se_GetDocumentationVersionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/versions");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetDocumentationVersionsCommand = se_GetDocumentationVersionsCommand;
 const se_GetDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetDomainNameCommand = se_GetDomainNameCommand;
 const se_GetDomainNamesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames";
+    b.bp("/domainnames");
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetDomainNamesCommand = se_GetDomainNamesCommand;
 const se_GetExportCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
-        accept: input.accepts,
+        [_ac]: input[_a],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/exports/{exportType}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "exportType", () => input.exportType, "{exportType}", false);
+    b.bp("/restapis/{restApiId}/stages/{stageName}/exports/{exportType}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("stageName", () => input.stageName, "{stageName}", false);
+    b.p("exportType", () => input.exportType, "{exportType}", false);
     const query = (0, smithy_client_1.map)({
         ...(0, smithy_client_1.convertMap)(input.parameters),
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetExportCommand = se_GetExportCommand;
 const se_GetGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
+    b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("responseType", () => input.responseType, "{responseType}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetGatewayResponseCommand = se_GetGatewayResponseCommand;
 const se_GetGatewayResponsesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/gatewayresponses";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/gatewayresponses");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetGatewayResponsesCommand = se_GetGatewayResponsesCommand;
 const se_GetIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetIntegrationCommand = se_GetIntegrationCommand;
 const se_GetIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetIntegrationResponseCommand = se_GetIntegrationResponseCommand;
 const se_GetMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetMethodCommand = se_GetMethodCommand;
 const se_GetMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetMethodResponseCommand = se_GetMethodResponseCommand;
 const se_GetModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
+    b.bp("/restapis/{restApiId}/models/{modelName}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("modelName", () => input.modelName, "{modelName}", false);
     const query = (0, smithy_client_1.map)({
-        flatten: [() => input.flatten !== void 0, () => input.flatten.toString()],
+        [_f]: [() => input.flatten !== void 0, () => input[_f].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetModelCommand = se_GetModelCommand;
 const se_GetModelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/models");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetModelsCommand = se_GetModelsCommand;
 const se_GetModelTemplateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/models/{modelName}/default_template";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
+    b.bp("/restapis/{restApiId}/models/{modelName}/default_template");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("modelName", () => input.modelName, "{modelName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetModelTemplateCommand = se_GetModelTemplateCommand;
 const se_GetRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
+    b.bp("/restapis/{restApiId}/requestvalidators/{requestValidatorId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetRequestValidatorCommand = se_GetRequestValidatorCommand;
 const se_GetRequestValidatorsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/requestvalidators";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/requestvalidators");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetRequestValidatorsCommand = se_GetRequestValidatorsCommand;
 const se_GetResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
     const query = (0, smithy_client_1.map)({
-        embed: [() => input.embed !== void 0, () => (input.embed || []).map((_entry) => _entry)],
+        [_e]: [() => input.embed !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetResourceCommand = se_GetResourceCommand;
 const se_GetResourcesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/resources";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/resources");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
-        embed: [() => input.embed !== void 0, () => (input.embed || []).map((_entry) => _entry)],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+        [_e]: [() => input.embed !== void 0, () => (input[_e] || []).map((_entry) => _entry)],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetResourcesCommand = se_GetResourcesCommand;
 const se_GetRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetRestApiCommand = se_GetRestApiCommand;
 const se_GetRestApisCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
+    b.bp("/restapis");
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetRestApisCommand = se_GetRestApisCommand;
 const se_GetSdkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/sdks/{sdkType}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "sdkType", () => input.sdkType, "{sdkType}", false);
+    b.bp("/restapis/{restApiId}/stages/{stageName}/sdks/{sdkType}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("stageName", () => input.stageName, "{stageName}", false);
+    b.p("sdkType", () => input.sdkType, "{sdkType}", false);
     const query = (0, smithy_client_1.map)({
         ...(0, smithy_client_1.convertMap)(input.parameters),
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetSdkCommand = se_GetSdkCommand;
 const se_GetSdkTypeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sdktypes/{id}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "id", () => input.id, "{id}", false);
+    b.bp("/sdktypes/{id}");
+    b.p("id", () => input.id, "{id}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetSdkTypeCommand = se_GetSdkTypeCommand;
 const se_GetSdkTypesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sdktypes";
+    b.bp("/sdktypes");
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetSdkTypesCommand = se_GetSdkTypesCommand;
 const se_GetStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
+    b.bp("/restapis/{restApiId}/stages/{stageName}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("stageName", () => input.stageName, "{stageName}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetStageCommand = se_GetStageCommand;
 const se_GetStagesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/stages");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        deploymentId: [, input.deploymentId],
+        [_dI]: [, input[_dI]],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetStagesCommand = se_GetStagesCommand;
 const se_GetTagsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetTagsCommand = se_GetTagsCommand;
 const se_GetUsageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/usage";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}/usage");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     const query = (0, smithy_client_1.map)({
-        keyId: [, input.keyId],
-        startDate: [, (0, smithy_client_1.expectNonNull)(input.startDate, `startDate`)],
-        endDate: [, (0, smithy_client_1.expectNonNull)(input.endDate, `endDate`)],
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_kI]: [, input[_kI]],
+        [_sD]: [, (0, smithy_client_1.expectNonNull)(input[_sD], `startDate`)],
+        [_eD]: [, (0, smithy_client_1.expectNonNull)(input[_eD], `endDate`)],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetUsageCommand = se_GetUsageCommand;
 const se_GetUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetUsagePlanCommand = se_GetUsagePlanCommand;
 const se_GetUsagePlanKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys/{keyId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "keyId", () => input.keyId, "{keyId}", false);
+    b.bp("/usageplans/{usagePlanId}/keys/{keyId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.p("keyId", () => input.keyId, "{keyId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetUsagePlanKeyCommand = se_GetUsagePlanKeyCommand;
 const se_GetUsagePlanKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}/keys");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
-        name: [, input.nameQuery],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+        [_n]: [, input[_nQ]],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetUsagePlanKeysCommand = se_GetUsagePlanKeysCommand;
 const se_GetUsagePlansCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans";
+    b.bp("/usageplans");
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        keyId: [, input.keyId],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_kI]: [, input[_kI]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetUsagePlansCommand = se_GetUsagePlansCommand;
 const se_GetVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
+    b.bp("/vpclinks/{vpcLinkId}");
+    b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 exports.se_GetVpcLinkCommand = se_GetVpcLinkCommand;
 const se_GetVpcLinksCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks";
+    b.bp("/vpclinks");
     const query = (0, smithy_client_1.map)({
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_GetVpcLinksCommand = se_GetVpcLinksCommand;
 const se_ImportApiKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
+    b.bp("/apikeys");
     const query = (0, smithy_client_1.map)({
-        mode: [, "import"],
-        format: [, (0, smithy_client_1.expectNonNull)(input.format, `format`)],
-        failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
+        [_m]: [, "import"],
+        [_fo]: [, (0, smithy_client_1.expectNonNull)(input[_fo], `format`)],
+        [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
     });
     let body;
     if (input.body !== undefined) {
         body = input.body;
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_ImportApiKeysCommand = se_ImportApiKeysCommand;
 const se_ImportDocumentationPartsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
-        mode: [, input.mode],
-        failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
+        [_m]: [, input[_m]],
+        [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
     });
     let body;
     if (input.body !== undefined) {
         body = input.body;
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_ImportDocumentationPartsCommand = se_ImportDocumentationPartsCommand;
 const se_ImportRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
+    b.bp("/restapis");
     const query = (0, smithy_client_1.map)({
-        mode: [, "import"],
+        [_m]: [, "import"],
         ...(0, smithy_client_1.convertMap)(input.parameters),
-        failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
+        [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
     });
     let body;
     if (input.body !== undefined) {
         body = input.body;
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_ImportRestApiCommand = se_ImportRestApiCommand;
 const se_PutGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
+    b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("responseType", () => input.responseType, "{responseType}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         responseParameters: (_) => (0, smithy_client_1._json)(_),
         responseTemplates: (_) => (0, smithy_client_1._json)(_),
         statusCode: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 exports.se_PutGatewayResponseCommand = se_PutGatewayResponseCommand;
 const se_PutIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         cacheKeyParameters: (_) => (0, smithy_client_1._json)(_),
@@ -1952,28 +1264,20 @@ const se_PutIntegrationCommand = async (input, context) => {
         type: [],
         uri: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 exports.se_PutIntegrationCommand = se_PutIntegrationCommand;
 const se_PutIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         contentHandling: [],
@@ -1981,27 +1285,19 @@ const se_PutIntegrationResponseCommand = async (input, context) => {
         responseTemplates: (_) => (0, smithy_client_1._json)(_),
         selectionPattern: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 exports.se_PutIntegrationResponseCommand = se_PutIntegrationResponseCommand;
 const se_PutMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         apiKeyRequired: [],
@@ -2013,103 +1309,72 @@ const se_PutMethodCommand = async (input, context) => {
         requestParameters: (_) => (0, smithy_client_1._json)(_),
         requestValidatorId: [],
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 exports.se_PutMethodCommand = se_PutMethodCommand;
 const se_PutMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         responseModels: (_) => (0, smithy_client_1._json)(_),
         responseParameters: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 exports.se_PutMethodResponseCommand = se_PutMethodResponseCommand;
 const se_PutRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = (0, smithy_client_1.map)({
         ...(0, smithy_client_1.convertMap)(input.parameters),
-        mode: [, input.mode],
-        failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
+        [_m]: [, input[_m]],
+        [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
     });
     let body;
     if (input.body !== undefined) {
         body = input.body;
     }
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_PutRestApiCommand = se_PutRestApiCommand;
 const se_TagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         tags: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 exports.se_TagResourceCommand = se_TagResourceCommand;
 const se_TestInvokeAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
+    b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         additionalContext: (_) => (0, smithy_client_1._json)(_),
@@ -2119,27 +1384,19 @@ const se_TestInvokeAuthorizerCommand = async (input, context) => {
         pathWithQueryString: [],
         stageVariables: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_TestInvokeAuthorizerCommand = se_TestInvokeAuthorizerCommand;
 const se_TestInvokeMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         body: [],
@@ -2149,556 +1406,374 @@ const se_TestInvokeMethodCommand = async (input, context) => {
         pathWithQueryString: [],
         stageVariables: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 exports.se_TestInvokeMethodCommand = se_TestInvokeMethodCommand;
 const se_UntagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     const query = (0, smithy_client_1.map)({
-        tagKeys: [
+        [_tK]: [
             (0, smithy_client_1.expectNonNull)(input.tagKeys, `tagKeys`) != null,
-            () => (input.tagKeys || []).map((_entry) => _entry),
+            () => (input[_tK] || []).map((_entry) => _entry),
         ],
     });
     let body;
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
 };
 exports.se_UntagResourceCommand = se_UntagResourceCommand;
 const se_UpdateAccountCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account";
+    b.bp("/account");
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateAccountCommand = se_UpdateAccountCommand;
 const se_UpdateApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
+    b.bp("/apikeys/{apiKey}");
+    b.p("apiKey", () => input.apiKey, "{apiKey}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateApiKeyCommand = se_UpdateApiKeyCommand;
 const se_UpdateAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "authorizerId", () => input.authorizerId, "{authorizerId}", false);
+    b.bp("/restapis/{restApiId}/authorizers/{authorizerId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("authorizerId", () => input.authorizerId, "{authorizerId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateAuthorizerCommand = se_UpdateAuthorizerCommand;
 const se_UpdateBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings/{basePath}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "basePath", () => input.basePath, "{basePath}", false);
+    b.bp("/domainnames/{domainName}/basepathmappings/{basePath}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
+    b.p("basePath", () => input.basePath, "{basePath}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateBasePathMappingCommand = se_UpdateBasePathMappingCommand;
 const se_UpdateClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
+    b.bp("/clientcertificates/{clientCertificateId}");
+    b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateClientCertificateCommand = se_UpdateClientCertificateCommand;
 const se_UpdateDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/deployments/{deploymentId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "deploymentId", () => input.deploymentId, "{deploymentId}", false);
+    b.bp("/restapis/{restApiId}/deployments/{deploymentId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("deploymentId", () => input.deploymentId, "{deploymentId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateDeploymentCommand = se_UpdateDeploymentCommand;
 const se_UpdateDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts/{documentationPartId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("documentationPartId", () => input.documentationPartId, "{documentationPartId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateDocumentationPartCommand = se_UpdateDocumentationPartCommand;
 const se_UpdateDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
+    b.bp("/restapis/{restApiId}/documentation/versions/{documentationVersion}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("documentationVersion", () => input.documentationVersion, "{documentationVersion}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateDocumentationVersionCommand = se_UpdateDocumentationVersionCommand;
 const se_UpdateDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateDomainNameCommand = se_UpdateDomainNameCommand;
 const se_UpdateGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "responseType", () => input.responseType, "{responseType}", false);
+    b.bp("/restapis/{restApiId}/gatewayresponses/{responseType}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("responseType", () => input.responseType, "{responseType}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateGatewayResponseCommand = se_UpdateGatewayResponseCommand;
 const se_UpdateIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateIntegrationCommand = se_UpdateIntegrationCommand;
 const se_UpdateIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateIntegrationResponseCommand = se_UpdateIntegrationResponseCommand;
 const se_UpdateMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateMethodCommand = se_UpdateMethodCommand;
 const se_UpdateMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "statusCode", () => input.statusCode, "{statusCode}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
+    b.p("httpMethod", () => input.httpMethod, "{httpMethod}", false);
+    b.p("statusCode", () => input.statusCode, "{statusCode}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateMethodResponseCommand = se_UpdateMethodResponseCommand;
 const se_UpdateModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "modelName", () => input.modelName, "{modelName}", false);
+    b.bp("/restapis/{restApiId}/models/{modelName}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("modelName", () => input.modelName, "{modelName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateModelCommand = se_UpdateModelCommand;
 const se_UpdateRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
+    b.bp("/restapis/{restApiId}/requestvalidators/{requestValidatorId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("requestValidatorId", () => input.requestValidatorId, "{requestValidatorId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateRequestValidatorCommand = se_UpdateRequestValidatorCommand;
 const se_UpdateResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
+    b.bp("/restapis/{restApiId}/resources/{resourceId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("resourceId", () => input.resourceId, "{resourceId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateResourceCommand = se_UpdateResourceCommand;
 const se_UpdateRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateRestApiCommand = se_UpdateRestApiCommand;
 const se_UpdateStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
+    b.bp("/restapis/{restApiId}/stages/{stageName}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
+    b.p("stageName", () => input.stageName, "{stageName}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateStageCommand = se_UpdateStageCommand;
 const se_UpdateUsageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/usageplans/{usagePlanId}/keys/{keyId}/usage";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "keyId", () => input.keyId, "{keyId}", false);
+    b.bp("/usageplans/{usagePlanId}/keys/{keyId}/usage");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.p("keyId", () => input.keyId, "{keyId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateUsageCommand = se_UpdateUsageCommand;
 const se_UpdateUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateUsagePlanCommand = se_UpdateUsagePlanCommand;
 const se_UpdateVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = (0, core_1.requestBuilder)(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
-    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
+    b.bp("/vpclinks/{vpcLinkId}");
+    b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
     let body;
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         patchOperations: (_) => (0, smithy_client_1._json)(_),
     }));
-    return new protocol_http_1.HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 exports.se_UpdateVpcLinkCommand = se_UpdateVpcLinkCommand;
 const de_CreateApiKeyCommand = async (output, context) => {
@@ -5355,8 +4430,8 @@ const de_GetExportCommand = async (output, context) => {
     }
     const contents = (0, smithy_client_1.map)({
         $metadata: deserializeMetadata(output),
-        contentType: [, output.headers["content-type"]],
-        contentDisposition: [, output.headers["content-disposition"]],
+        [_cT]: [, output.headers[_ct]],
+        [_cD]: [, output.headers[_cd]],
     });
     const data = await (0, smithy_client_1.collectBody)(output.body, context);
     contents.body = data;
@@ -6102,8 +5177,8 @@ const de_GetSdkCommand = async (output, context) => {
     }
     const contents = (0, smithy_client_1.map)({
         $metadata: deserializeMetadata(output),
-        contentType: [, output.headers["content-type"]],
-        contentDisposition: [, output.headers["content-disposition"]],
+        [_cT]: [, output.headers[_ct]],
+        [_cD]: [, output.headers[_cd]],
     });
     const data = await (0, smithy_client_1.collectBody)(output.body, context);
     contents.body = data;
@@ -8650,7 +7725,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
 };
 const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = (0, smithy_client_1.map)({
-        retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
+        [_rAS]: [, parsedOutput.headers[_ra]],
     });
     const data = parsedOutput.body;
     const doc = (0, smithy_client_1.take)(data, {
@@ -8678,7 +7753,7 @@ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
 };
 const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = (0, smithy_client_1.map)({
-        retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
+        [_rAS]: [, parsedOutput.headers[_ra]],
     });
     const data = parsedOutput.body;
     const doc = (0, smithy_client_1.take)(data, {
@@ -8693,7 +7768,7 @@ const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
 };
 const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
     const contents = (0, smithy_client_1.map)({
-        retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
+        [_rAS]: [, parsedOutput.headers[_ra]],
     });
     const data = parsedOutput.body;
     const doc = (0, smithy_client_1.take)(data, {
@@ -9011,6 +8086,35 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _a = "accepts";
+const _ac = "accept";
+const _cD = "contentDisposition";
+const _cI = "customerId";
+const _cT = "contentType";
+const _cd = "content-disposition";
+const _ct = "content-type";
+const _dI = "deploymentId";
+const _e = "embed";
+const _eD = "endDate";
+const _f = "flatten";
+const _fOW = "failOnWarnings";
+const _fa = "failonwarnings";
+const _fo = "format";
+const _iV = "includeValue";
+const _iVn = "includeValues";
+const _kI = "keyId";
+const _l = "limit";
+const _lS = "locationStatus";
+const _m = "mode";
+const _n = "name";
+const _nQ = "nameQuery";
+const _p = "position";
+const _pa = "path";
+const _rAS = "retryAfterSeconds";
+const _ra = "retry-after";
+const _sD = "startDate";
+const _t = "type";
+const _tK = "tagKeys";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);