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

package/dist-es/protocols/Aws_restJson1.js

@@ -1,13 +1,13 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, convertMap, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
+import { requestBuilder as rb } from "@smithy/core";
+import { _json, collectBody, convertMap, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { APIGatewayServiceException as __BaseException } from "../models/APIGatewayServiceException";
 import { BadRequestException, ConflictException, LimitExceededException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, } from "../models/models_0";
 export const se_CreateApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
+    b.bp("/apikeys");
     let body;
     body = JSON.stringify(take(input, {
         customerId: [],
@@ -19,23 +19,16 @@ export const se_CreateApiKeyCommand = async (input, context) => {
         tags: (_) => _json(_),
         value: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/authorizers";
-    resolvedPath = __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(take(input, {
         authType: [],
@@ -48,47 +41,32 @@ export const se_CreateAuthorizerCommand = async (input, context) => {
         providerARNs: (_) => _json(_),
         type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings";
-    resolvedPath = __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(take(input, {
         basePath: [],
         restApiId: [],
         stage: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/deployments";
-    resolvedPath = __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(take(input, {
         cacheClusterEnabled: [],
@@ -100,68 +78,46 @@ export const se_CreateDeploymentCommand = async (input, context) => {
         tracingEnabled: [],
         variables: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
-    resolvedPath = __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(take(input, {
         location: (_) => _json(_),
         properties: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions";
-    resolvedPath = __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(take(input, {
         description: [],
         documentationVersion: [],
         stageName: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames";
+    b.bp("/domainnames");
     let body;
     body = JSON.stringify(take(input, {
         certificateArn: [],
@@ -178,23 +134,16 @@ export const se_CreateDomainNameCommand = async (input, context) => {
         securityPolicy: [],
         tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models";
-    resolvedPath = __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(take(input, {
         contentType: [],
@@ -202,68 +151,46 @@ export const se_CreateModelCommand = async (input, context) => {
         name: [],
         schema: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/requestvalidators";
-    resolvedPath = __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(take(input, {
         name: [],
         validateRequestBody: [],
         validateRequestParameters: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{parentId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         pathPart: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
+    b.bp("/restapis");
     let body;
     body = JSON.stringify(take(input, {
         apiKeySource: [],
@@ -278,23 +205,16 @@ export const se_CreateRestApiCommand = async (input, context) => {
         tags: (_) => _json(_),
         version: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages";
-    resolvedPath = __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(take(input, {
         cacheClusterEnabled: [],
@@ -308,22 +228,15 @@ export const se_CreateStageCommand = async (input, context) => {
         tracingEnabled: [],
         variables: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans";
+    b.bp("/usageplans");
     let body;
     body = JSON.stringify(take(input, {
         apiStages: (_) => se_ListOfApiStage(_, context),
@@ -333,44 +246,30 @@ export const se_CreateUsagePlanCommand = async (input, context) => {
         tags: (_) => _json(_),
         throttle: (_) => se_ThrottleSettings(_, context),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateUsagePlanKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys";
-    resolvedPath = __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(take(input, {
         keyId: [],
         keyType: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks";
+    b.bp("/vpclinks");
     let body;
     body = JSON.stringify(take(input, {
         description: [],
@@ -378,1467 +277,880 @@ export const se_CreateVpcLinkCommand = async (input, context) => {
         tags: (_) => _json(_),
         targetArns: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
+    b.bp("/apikeys/{apiKey}");
+    b.p("apiKey", () => input.apiKey, "{apiKey}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings/{basePath}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
+    b.bp("/clientcertificates/{clientCertificateId}");
+    b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/deployments/{deploymentId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteUsagePlanKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys/{keyId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
+    b.bp("/vpclinks/{vpcLinkId}");
+    b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_FlushStageAuthorizersCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/cache/authorizers";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_FlushStageCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/cache/data";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_GenerateClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates";
+    b.bp("/clientcertificates");
     let body;
     body = JSON.stringify(take(input, {
         description: [],
         tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_GetAccountCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account";
+    b.bp("/account");
     let body;
     body = "";
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
+    b.bp("/apikeys/{apiKey}");
+    b.p("apiKey", () => input.apiKey, "{apiKey}", false);
     const query = map({
-        includeValue: [() => input.includeValue !== void 0, () => input.includeValue.toString()],
+        [_iV]: [() => input.includeValue !== void 0, () => input[_iV].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetApiKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
+    b.bp("/apikeys");
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetAuthorizersCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/authorizers";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/authorizers");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings/{basePath}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetBasePathMappingsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}/basepathmappings");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
+    b.bp("/clientcertificates/{clientCertificateId}");
+    b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetClientCertificatesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates";
+    b.bp("/clientcertificates");
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/deployments/{deploymentId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetDeploymentsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/deployments";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/deployments");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetDocumentationPartsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetDocumentationVersionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/versions");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetDomainNamesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames";
+    b.bp("/domainnames");
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetExportCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        accept: input.accepts,
+        [_ac]: input[_a],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/exports/{exportType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
-    resolvedPath = __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 = map({
         ...convertMap(input.parameters),
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetGatewayResponsesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/gatewayresponses";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/gatewayresponses");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 = map({
-        flatten: [() => input.flatten !== void 0, () => input.flatten.toString()],
+        [_f]: [() => input.flatten !== void 0, () => input[_f].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetModelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/models");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetModelTemplateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/models/{modelName}/default_template";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetRequestValidatorsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/requestvalidators";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/requestvalidators");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetResourcesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/resources";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/resources");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetRestApisCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
+    b.bp("/restapis");
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetSdkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/stages/{stageName}/sdks/{sdkType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "stageName", () => input.stageName, "{stageName}", false);
-    resolvedPath = __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 = map({
         ...convertMap(input.parameters),
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetSdkTypeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sdktypes/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    b.bp("/sdktypes/{id}");
+    b.p("id", () => input.id, "{id}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetSdkTypesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/sdktypes";
+    b.bp("/sdktypes");
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetStagesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/stages");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = map({
-        deploymentId: [, input.deploymentId],
+        [_dI]: [, input[_dI]],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetTagsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetUsageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/usage";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}/usage");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     const query = map({
-        keyId: [, input.keyId],
-        startDate: [, __expectNonNull(input.startDate, `startDate`)],
-        endDate: [, __expectNonNull(input.endDate, `endDate`)],
-        position: [, input.position],
-        limit: [() => input.limit !== void 0, () => input.limit.toString()],
+        [_kI]: [, input[_kI]],
+        [_sD]: [, __expectNonNull(input[_sD], `startDate`)],
+        [_eD]: [, __expectNonNull(input[_eD], `endDate`)],
+        [_p]: [, input[_p]],
+        [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetUsagePlanKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys/{keyId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
-    resolvedPath = __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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetUsagePlanKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}/keys";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}/keys");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetUsagePlansCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans";
+    b.bp("/usageplans");
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
+    b.bp("/vpclinks/{vpcLinkId}");
+    b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetVpcLinksCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks";
+    b.bp("/vpclinks");
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ImportApiKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys";
+    b.bp("/apikeys");
     const query = map({
-        mode: [, "import"],
-        format: [, __expectNonNull(input.format, `format`)],
-        failonwarnings: [() => input.failOnWarnings !== void 0, () => input.failOnWarnings.toString()],
+        [_m]: [, "import"],
+        [_fo]: [, __expectNonNull(input[_fo], `format`)],
+        [_fa]: [() => input.failOnWarnings !== void 0, () => input[_fOW].toString()],
     });
     let body;
     if (input.body !== undefined) {
         body = input.body;
     }
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ImportDocumentationPartsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/documentation/parts";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}/documentation/parts");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = 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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ImportRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis";
+    b.bp("/restapis");
     const query = map({
-        mode: [, "import"],
+        [_m]: [, "import"],
         ...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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_PutGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         responseParameters: (_) => _json(_),
         responseTemplates: (_) => _json(_),
         statusCode: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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(take(input, {
         cacheKeyParameters: (_) => _json(_),
@@ -1856,27 +1168,19 @@ export const se_PutIntegrationCommand = async (input, context) => {
         type: [],
         uri: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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(take(input, {
         contentHandling: [],
@@ -1884,26 +1188,18 @@ export const se_PutIntegrationResponseCommand = async (input, context) => {
         responseTemplates: (_) => _json(_),
         selectionPattern: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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(take(input, {
         apiKeyRequired: [],
@@ -1915,99 +1211,68 @@ export const se_PutMethodCommand = async (input, context) => {
         requestParameters: (_) => _json(_),
         requestValidatorId: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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(take(input, {
         responseModels: (_) => _json(_),
         responseParameters: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/octet-stream",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     const query = map({
         ...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 __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_TagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_TestInvokeAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         additionalContext: (_) => _json(_),
@@ -2017,26 +1282,18 @@ export const se_TestInvokeAuthorizerCommand = async (input, context) => {
         pathWithQueryString: [],
         stageVariables: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_TestInvokeMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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(take(input, {
         body: [],
@@ -2046,533 +1303,351 @@ export const se_TestInvokeMethodCommand = async (input, context) => {
         pathWithQueryString: [],
         stageVariables: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UntagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     const query = map({
-        tagKeys: [
+        [_tK]: [
             __expectNonNull(input.tagKeys, `tagKeys`) != null,
-            () => (input.tagKeys || []).map((_entry) => _entry),
+            () => (input[_tK] || []).map((_entry) => _entry),
         ],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_UpdateAccountCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account";
+    b.bp("/account");
     let body;
     body = JSON.stringify(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/apikeys/{apiKey}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiKey", () => input.apiKey, "{apiKey}", false);
+    b.bp("/apikeys/{apiKey}");
+    b.p("apiKey", () => input.apiKey, "{apiKey}", false);
     let body;
     body = JSON.stringify(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateAuthorizerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/authorizers/{authorizerId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateBasePathMappingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/domainnames/{domainName}/basepathmappings/{basePath}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateClientCertificateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clientcertificates/{clientCertificateId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
+    b.bp("/clientcertificates/{clientCertificateId}");
+    b.p("clientCertificateId", () => input.clientCertificateId, "{clientCertificateId}", false);
     let body;
     body = JSON.stringify(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateDeploymentCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/deployments/{deploymentId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateDocumentationPartCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/parts/{documentationPartId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateDocumentationVersionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/documentation/versions/{documentationVersion}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/domainnames/{domainName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
     body = JSON.stringify(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateGatewayResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/gatewayresponses/{responseType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateIntegrationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateIntegrationResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/integration/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateMethodCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateMethodResponseCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}/methods/{httpMethod}/responses/{statusCode}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceId", () => input.resourceId, "{resourceId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "httpMethod", () => input.httpMethod, "{httpMethod}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateModelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/models/{modelName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateRequestValidatorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/requestvalidators/{requestValidatorId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/restapis/{restApiId}/resources/{resourceId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateRestApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
+    b.bp("/restapis/{restApiId}");
+    b.p("restApiId", () => input.restApiId, "{restApiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateStageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restapis/{restApiId}/stages/{stageName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "restApiId", () => input.restApiId, "{restApiId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateUsageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/usageplans/{usagePlanId}/keys/{keyId}/usage";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
-    resolvedPath = __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(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateUsagePlanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/usageplans/{usagePlanId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
+    b.bp("/usageplans/{usagePlanId}");
+    b.p("usagePlanId", () => input.usagePlanId, "{usagePlanId}", false);
     let body;
     body = JSON.stringify(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateVpcLinkCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vpclinks/{vpcLinkId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
+    b.bp("/vpclinks/{vpcLinkId}");
+    b.p("vpcLinkId", () => input.vpcLinkId, "{vpcLinkId}", false);
     let body;
     body = JSON.stringify(take(input, {
         patchOperations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
 };
 export const de_CreateApiKeyCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -5172,8 +4247,8 @@ export const de_GetExportCommand = async (output, context) => {
     }
     const contents = 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 collectBody(output.body, context);
     contents.body = data;
@@ -5903,8 +4978,8 @@ export const de_GetSdkCommand = async (output, context) => {
     }
     const contents = 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 collectBody(output.body, context);
     contents.body = data;
@@ -8403,7 +7478,7 @@ const de_ConflictExceptionRes = async (parsedOutput, context) => {
 };
 const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({
-        retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
+        [_rAS]: [, parsedOutput.headers[_ra]],
     });
     const data = parsedOutput.body;
     const doc = take(data, {
@@ -8431,7 +7506,7 @@ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
 };
 const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = map({
-        retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
+        [_rAS]: [, parsedOutput.headers[_ra]],
     });
     const data = parsedOutput.body;
     const doc = take(data, {
@@ -8446,7 +7521,7 @@ const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
 };
 const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
     const contents = map({
-        retryAfterSeconds: [, parsedOutput.headers["retry-after"]],
+        [_rAS]: [, parsedOutput.headers[_ra]],
     });
     const data = parsedOutput.body;
     const doc = take(data, {
@@ -8764,6 +7839,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);