@aws-sdk/client-lambda 3.476.0 → 3.478.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,18 +1,17 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, 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, 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 { LambdaServiceException as __BaseException } from "../models/LambdaServiceException";
 import { CodeSigningConfigNotFoundException, CodeStorageExceededException, CodeVerificationFailedException, EC2AccessDeniedException, EC2ThrottledException, EC2UnexpectedException, EFSIOException, EFSMountConnectivityException, EFSMountFailureException, EFSMountTimeoutException, ENILimitReachedException, InvalidCodeSignatureException, InvalidParameterValueException, InvalidRequestContentException, InvalidRuntimeException, InvalidSecurityGroupIDException, InvalidSubnetIDException, InvalidZipFileException, KMSAccessDeniedException, KMSDisabledException, KMSInvalidStateException, KMSNotFoundException, PolicyLengthExceededException, PreconditionFailedException, ProvisionedConcurrencyConfigNotFoundException, RecursiveInvocationException, RequestTooLargeException, ResourceConflictException, ResourceInUseException, ResourceNotFoundException, ResourceNotReadyException, ServiceException, SnapStartException, SnapStartNotReadyException, SnapStartTimeoutException, SubnetIPAddressLimitReachedException, TooManyRequestsException, UnsupportedMediaTypeException, } from "../models/models_0";
 export const se_AddLayerVersionPermissionCommand = 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 || ""}` +
-        "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy";
-    resolvedPath = __resolvedPath(resolvedPath, input, "LayerName", () => input.LayerName, "{LayerName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
+    b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy");
+    b.p("LayerName", () => input.LayerName, "{LayerName}", false);
+    b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
     const query = map({
-        RevisionId: [, input.RevisionId],
+        [_RI]: [, input[_RI]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -21,27 +20,18 @@ export const se_AddLayerVersionPermissionCommand = async (input, context) => {
         Principal: [],
         StatementId: [],
     }));
-    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_AddPermissionCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/policy";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/policy");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -55,25 +45,16 @@ export const se_AddPermissionCommand = async (input, context) => {
         SourceArn: [],
         StatementId: [],
     }));
-    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_CreateAliasCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/aliases";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/aliases");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     let body;
     body = JSON.stringify(take(input, {
         Description: [],
@@ -81,44 +62,30 @@ export const se_CreateAliasCommand = async (input, context) => {
         Name: [],
         RoutingConfig: (_) => se_AliasRoutingConfiguration(_, 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_CreateCodeSigningConfigCommand = 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 || ""}` + "/2020-04-22/code-signing-configs";
+    b.bp("/2020-04-22/code-signing-configs");
     let body;
     body = JSON.stringify(take(input, {
         AllowedPublishers: (_) => _json(_),
         CodeSigningPolicies: (_) => _json(_),
         Description: [],
     }));
-    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_CreateEventSourceMappingCommand = 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 || ""}` + "/2015-03-31/event-source-mappings";
+    b.bp("/2015-03-31/event-source-mappings");
     let body;
     body = JSON.stringify(take(input, {
         AmazonManagedKafkaEventSourceConfig: (_) => _json(_),
@@ -145,22 +112,15 @@ export const se_CreateEventSourceMappingCommand = async (input, context) => {
         Topics: (_) => _json(_),
         TumblingWindowInSeconds: [],
     }));
-    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_CreateFunctionCommand = 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 || ""}` + "/2015-03-31/functions";
+    b.bp("/2015-03-31/functions");
     let body;
     body = JSON.stringify(take(input, {
         Architectures: (_) => _json(_),
@@ -188,25 +148,18 @@ export const se_CreateFunctionCommand = async (input, context) => {
         TracingConfig: (_) => _json(_),
         VpcConfig: (_) => _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_CreateFunctionUrlConfigCommand = 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 || ""}` + "/2021-10-31/functions/{FunctionName}/url";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-10-31/functions/{FunctionName}/url");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -214,851 +167,505 @@ export const se_CreateFunctionUrlConfigCommand = async (input, context) => {
         Cors: (_) => _json(_),
         InvokeMode: [],
     }));
-    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_DeleteAliasCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/aliases/{Name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/aliases/{Name}");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.p("Name", () => input.Name, "{Name}", 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_DeleteCodeSigningConfigCommand = 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 || ""}` +
-        "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
+    b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}");
+    b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", 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_DeleteEventSourceMappingCommand = 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 || ""}` + "/2015-03-31/event-source-mappings/{UUID}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "UUID", () => input.UUID, "{UUID}", false);
+    b.bp("/2015-03-31/event-source-mappings/{UUID}");
+    b.p("UUID", () => input.UUID, "{UUID}", 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_DeleteFunctionCommand = 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 || ""}` + "/2015-03-31/functions/{FunctionName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_DeleteFunctionCodeSigningConfigCommand = 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 || ""}` +
-        "/2020-06-30/functions/{FunctionName}/code-signing-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2020-06-30/functions/{FunctionName}/code-signing-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", 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_DeleteFunctionConcurrencyCommand = 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 || ""}` +
-        "/2017-10-31/functions/{FunctionName}/concurrency";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2017-10-31/functions/{FunctionName}/concurrency");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", 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_DeleteFunctionEventInvokeConfigCommand = 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 || ""}` +
-        "/2019-09-25/functions/{FunctionName}/event-invoke-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_DeleteFunctionUrlConfigCommand = 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 || ""}` + "/2021-10-31/functions/{FunctionName}/url";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-10-31/functions/{FunctionName}/url");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_DeleteLayerVersionCommand = 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 || ""}` +
-        "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "LayerName", () => input.LayerName, "{LayerName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
+    b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}");
+    b.p("LayerName", () => input.LayerName, "{LayerName}", false);
+    b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", 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_DeleteProvisionedConcurrencyConfigCommand = 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 || ""}` +
-        "/2019-09-30/functions/{FunctionName}/provisioned-concurrency";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, __expectNonNull(input.Qualifier, `Qualifier`)],
+        [_Q]: [, __expectNonNull(input[_Q], `Qualifier`)],
     });
     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_GetAccountSettingsCommand = 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 || ""}` + "/2016-08-19/account-settings";
+    b.bp("/2016-08-19/account-settings");
     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_GetAliasCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/aliases/{Name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/aliases/{Name}");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.p("Name", () => input.Name, "{Name}", 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_GetCodeSigningConfigCommand = 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 || ""}` +
-        "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
+    b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}");
+    b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", 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_GetEventSourceMappingCommand = 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 || ""}` + "/2015-03-31/event-source-mappings/{UUID}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "UUID", () => input.UUID, "{UUID}", false);
+    b.bp("/2015-03-31/event-source-mappings/{UUID}");
+    b.p("UUID", () => input.UUID, "{UUID}", 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_GetFunctionCommand = 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 || ""}` + "/2015-03-31/functions/{FunctionName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_GetFunctionCodeSigningConfigCommand = 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 || ""}` +
-        "/2020-06-30/functions/{FunctionName}/code-signing-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2020-06-30/functions/{FunctionName}/code-signing-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", 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_GetFunctionConcurrencyCommand = 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 || ""}` +
-        "/2019-09-30/functions/{FunctionName}/concurrency";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-30/functions/{FunctionName}/concurrency");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", 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_GetFunctionConfigurationCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/configuration";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/configuration");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_GetFunctionEventInvokeConfigCommand = 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 || ""}` +
-        "/2019-09-25/functions/{FunctionName}/event-invoke-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_GetFunctionUrlConfigCommand = 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 || ""}` + "/2021-10-31/functions/{FunctionName}/url";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-10-31/functions/{FunctionName}/url");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_GetLayerVersionCommand = 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 || ""}` +
-        "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "LayerName", () => input.LayerName, "{LayerName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
+    b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}");
+    b.p("LayerName", () => input.LayerName, "{LayerName}", false);
+    b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", 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_GetLayerVersionByArnCommand = 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 || ""}` + "/2018-10-31/layers";
+    b.bp("/2018-10-31/layers");
     const query = map({
-        find: [, "LayerVersion"],
-        Arn: [, __expectNonNull(input.Arn, `Arn`)],
+        [_f]: [, "LayerVersion"],
+        [_A]: [, __expectNonNull(input[_A], `Arn`)],
     });
     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_GetLayerVersionPolicyCommand = 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 || ""}` +
-        "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy";
-    resolvedPath = __resolvedPath(resolvedPath, input, "LayerName", () => input.LayerName, "{LayerName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
+    b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy");
+    b.p("LayerName", () => input.LayerName, "{LayerName}", false);
+    b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", 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_GetPolicyCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/policy";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/policy");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_GetProvisionedConcurrencyConfigCommand = 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 || ""}` +
-        "/2019-09-30/functions/{FunctionName}/provisioned-concurrency";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, __expectNonNull(input.Qualifier, `Qualifier`)],
+        [_Q]: [, __expectNonNull(input[_Q], `Qualifier`)],
     });
     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_GetRuntimeManagementConfigCommand = 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 || ""}` +
-        "/2021-07-20/functions/{FunctionName}/runtime-management-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-07-20/functions/{FunctionName}/runtime-management-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     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_InvokeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/octet-stream",
-        "x-amz-invocation-type": input.InvocationType,
-        "x-amz-log-type": input.LogType,
-        "x-amz-client-context": input.ClientContext,
+        [_xait]: input[_IT],
+        [_xalt]: input[_LT],
+        [_xacc]: input[_CC],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/2015-03-31/functions/{FunctionName}/invocations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/invocations");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     if (input.Payload !== undefined) {
         body = input.Payload;
     }
-    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_InvokeAsyncCommand = 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 || ""}` +
-        "/2014-11-13/functions/{FunctionName}/invoke-async";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2014-11-13/functions/{FunctionName}/invoke-async");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     let body;
     if (input.InvokeArgs !== undefined) {
         body = input.InvokeArgs;
     }
-    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_InvokeWithResponseStreamCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/octet-stream",
-        "x-amz-invocation-type": input.InvocationType,
-        "x-amz-log-type": input.LogType,
-        "x-amz-client-context": input.ClientContext,
+        [_xait]: input[_IT],
+        [_xalt]: input[_LT],
+        [_xacc]: input[_CC],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/2021-11-15/functions/{FunctionName}/response-streaming-invocations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-11-15/functions/{FunctionName}/response-streaming-invocations");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     if (input.Payload !== undefined) {
         body = input.Payload;
     }
-    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_ListAliasesCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/aliases";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/aliases");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        FunctionVersion: [, input.FunctionVersion],
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_FV]: [, input[_FV]],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListCodeSigningConfigsCommand = 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 || ""}` + "/2020-04-22/code-signing-configs";
+    b.bp("/2020-04-22/code-signing-configs");
     const query = map({
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListEventSourceMappingsCommand = 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 || ""}` + "/2015-03-31/event-source-mappings";
+    b.bp("/2015-03-31/event-source-mappings");
     const query = map({
-        EventSourceArn: [, input.EventSourceArn],
-        FunctionName: [, input.FunctionName],
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_ESA]: [, input[_ESA]],
+        [_FN]: [, input[_FN]],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListFunctionEventInvokeConfigsCommand = 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 || ""}` +
-        "/2019-09-25/functions/{FunctionName}/event-invoke-config/list";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config/list");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListFunctionsCommand = 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 || ""}` + "/2015-03-31/functions";
+    b.bp("/2015-03-31/functions");
     const query = map({
-        MasterRegion: [, input.MasterRegion],
-        FunctionVersion: [, input.FunctionVersion],
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_MR]: [, input[_MR]],
+        [_FV]: [, input[_FV]],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListFunctionsByCodeSigningConfigCommand = 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 || ""}` +
-        "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}/functions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
+    b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}/functions");
+    b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
     const query = map({
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListFunctionUrlConfigsCommand = 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 || ""}` + "/2021-10-31/functions/{FunctionName}/urls";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-10-31/functions/{FunctionName}/urls");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListLayersCommand = 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 || ""}` + "/2018-10-31/layers";
+    b.bp("/2018-10-31/layers");
     const query = map({
-        CompatibleRuntime: [, input.CompatibleRuntime],
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
-        CompatibleArchitecture: [, input.CompatibleArchitecture],
+        [_CR]: [, input[_CR]],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()],
+        [_CA]: [, input[_CA]],
     });
     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_ListLayerVersionsCommand = 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 || ""}` + "/2018-10-31/layers/{LayerName}/versions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "LayerName", () => input.LayerName, "{LayerName}", false);
+    b.bp("/2018-10-31/layers/{LayerName}/versions");
+    b.p("LayerName", () => input.LayerName, "{LayerName}", false);
     const query = map({
-        CompatibleRuntime: [, input.CompatibleRuntime],
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
-        CompatibleArchitecture: [, input.CompatibleArchitecture],
+        [_CR]: [, input[_CR]],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()],
+        [_CA]: [, input[_CA]],
     });
     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_ListProvisionedConcurrencyConfigsCommand = 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 || ""}` +
-        "/2019-09-30/functions/{FunctionName}/provisioned-concurrency";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        List: [, "ALL"],
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_L]: [, "ALL"],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_ListTagsCommand = 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 || ""}` + "/2017-03-31/tags/{Resource}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Resource", () => input.Resource, "{Resource}", false);
+    b.bp("/2017-03-31/tags/{Resource}");
+    b.p("Resource", () => input.Resource, "{Resource}", 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_ListVersionsByFunctionCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/versions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/versions");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Marker: [, input.Marker],
-        MaxItems: [() => input.MaxItems !== void 0, () => input.MaxItems.toString()],
+        [_M]: [, input[_M]],
+        [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].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_PublishLayerVersionCommand = 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 || ""}` + "/2018-10-31/layers/{LayerName}/versions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "LayerName", () => input.LayerName, "{LayerName}", false);
+    b.bp("/2018-10-31/layers/{LayerName}/versions");
+    b.p("LayerName", () => input.LayerName, "{LayerName}", false);
     let body;
     body = JSON.stringify(take(input, {
         CompatibleArchitectures: (_) => _json(_),
@@ -1067,94 +674,62 @@ export const se_PublishLayerVersionCommand = async (input, context) => {
         Description: [],
         LicenseInfo: [],
     }));
-    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_PublishVersionCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/versions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/versions");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     let body;
     body = JSON.stringify(take(input, {
         CodeSha256: [],
         Description: [],
         RevisionId: [],
     }));
-    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_PutFunctionCodeSigningConfigCommand = 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 || ""}` +
-        "/2020-06-30/functions/{FunctionName}/code-signing-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2020-06-30/functions/{FunctionName}/code-signing-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     let body;
     body = JSON.stringify(take(input, {
         CodeSigningConfigArn: [],
     }));
-    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_PutFunctionConcurrencyCommand = 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 || ""}` +
-        "/2017-10-31/functions/{FunctionName}/concurrency";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2017-10-31/functions/{FunctionName}/concurrency");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     let body;
     body = JSON.stringify(take(input, {
         ReservedConcurrentExecutions: [],
     }));
-    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_PutFunctionEventInvokeConfigCommand = 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 || ""}` +
-        "/2019-09-25/functions/{FunctionName}/event-invoke-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -1162,169 +737,109 @@ export const se_PutFunctionEventInvokeConfigCommand = async (input, context) =>
         MaximumEventAgeInSeconds: [],
         MaximumRetryAttempts: [],
     }));
-    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_PutProvisionedConcurrencyConfigCommand = 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 || ""}` +
-        "/2019-09-30/functions/{FunctionName}/provisioned-concurrency";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-30/functions/{FunctionName}/provisioned-concurrency");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, __expectNonNull(input.Qualifier, `Qualifier`)],
+        [_Q]: [, __expectNonNull(input[_Q], `Qualifier`)],
     });
     let body;
     body = JSON.stringify(take(input, {
         ProvisionedConcurrentExecutions: [],
     }));
-    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_PutRuntimeManagementConfigCommand = 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 || ""}` +
-        "/2021-07-20/functions/{FunctionName}/runtime-management-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-07-20/functions/{FunctionName}/runtime-management-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     body = JSON.stringify(take(input, {
         RuntimeVersionArn: [],
         UpdateRuntimeOn: [],
     }));
-    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_RemoveLayerVersionPermissionCommand = 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 || ""}` +
-        "/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy/{StatementId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "LayerName", () => input.LayerName, "{LayerName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "StatementId", () => input.StatementId, "{StatementId}", false);
+    b.bp("/2018-10-31/layers/{LayerName}/versions/{VersionNumber}/policy/{StatementId}");
+    b.p("LayerName", () => input.LayerName, "{LayerName}", false);
+    b.p("VersionNumber", () => input.VersionNumber.toString(), "{VersionNumber}", false);
+    b.p("StatementId", () => input.StatementId, "{StatementId}", false);
     const query = map({
-        RevisionId: [, input.RevisionId],
+        [_RI]: [, input[_RI]],
     });
     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_RemovePermissionCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/policy/{StatementId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "StatementId", () => input.StatementId, "{StatementId}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/policy/{StatementId}");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.p("StatementId", () => input.StatementId, "{StatementId}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
-        RevisionId: [, input.RevisionId],
+        [_Q]: [, input[_Q]],
+        [_RI]: [, input[_RI]],
     });
     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_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 || ""}` + "/2017-03-31/tags/{Resource}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Resource", () => input.Resource, "{Resource}", false);
+    b.bp("/2017-03-31/tags/{Resource}");
+    b.p("Resource", () => input.Resource, "{Resource}", false);
     let body;
     body = JSON.stringify(take(input, {
         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_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 || ""}` + "/2017-03-31/tags/{Resource}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Resource", () => input.Resource, "{Resource}", false);
+    b.bp("/2017-03-31/tags/{Resource}");
+    b.p("Resource", () => input.Resource, "{Resource}", 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_UpdateAliasCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/aliases/{Name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/aliases/{Name}");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.p("Name", () => input.Name, "{Name}", false);
     let body;
     body = JSON.stringify(take(input, {
         Description: [],
@@ -1332,47 +847,32 @@ export const se_UpdateAliasCommand = async (input, context) => {
         RevisionId: [],
         RoutingConfig: (_) => se_AliasRoutingConfiguration(_, context),
     }));
-    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_UpdateCodeSigningConfigCommand = 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 || ""}` +
-        "/2020-04-22/code-signing-configs/{CodeSigningConfigArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
+    b.bp("/2020-04-22/code-signing-configs/{CodeSigningConfigArn}");
+    b.p("CodeSigningConfigArn", () => input.CodeSigningConfigArn, "{CodeSigningConfigArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         AllowedPublishers: (_) => _json(_),
         CodeSigningPolicies: (_) => _json(_),
         Description: [],
     }));
-    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_UpdateEventSourceMappingCommand = 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 || ""}` + "/2015-03-31/event-source-mappings/{UUID}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "UUID", () => input.UUID, "{UUID}", false);
+    b.bp("/2015-03-31/event-source-mappings/{UUID}");
+    b.p("UUID", () => input.UUID, "{UUID}", false);
     let body;
     body = JSON.stringify(take(input, {
         BatchSize: [],
@@ -1391,23 +891,16 @@ export const se_UpdateEventSourceMappingCommand = async (input, context) => {
         SourceAccessConfigurations: (_) => _json(_),
         TumblingWindowInSeconds: [],
     }));
-    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_UpdateFunctionCodeCommand = 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 || ""}` + "/2015-03-31/functions/{FunctionName}/code";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/code");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     let body;
     body = JSON.stringify(take(input, {
         Architectures: (_) => _json(_),
@@ -1420,24 +913,16 @@ export const se_UpdateFunctionCodeCommand = async (input, context) => {
         S3ObjectVersion: [],
         ZipFile: (_) => context.base64Encoder(_),
     }));
-    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_UpdateFunctionConfigurationCommand = 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 || ""}` +
-        "/2015-03-31/functions/{FunctionName}/configuration";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2015-03-31/functions/{FunctionName}/configuration");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     let body;
     body = JSON.stringify(take(input, {
         DeadLetterConfig: (_) => _json(_),
@@ -1459,26 +944,18 @@ export const se_UpdateFunctionConfigurationCommand = async (input, context) => {
         TracingConfig: (_) => _json(_),
         VpcConfig: (_) => _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_UpdateFunctionEventInvokeConfigCommand = 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 || ""}` +
-        "/2019-09-25/functions/{FunctionName}/event-invoke-config";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2019-09-25/functions/{FunctionName}/event-invoke-config");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -1486,26 +963,18 @@ export const se_UpdateFunctionEventInvokeConfigCommand = async (input, context)
         MaximumEventAgeInSeconds: [],
         MaximumRetryAttempts: [],
     }));
-    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_UpdateFunctionUrlConfigCommand = 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 || ""}` + "/2021-10-31/functions/{FunctionName}/url";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FunctionName", () => input.FunctionName, "{FunctionName}", false);
+    b.bp("/2021-10-31/functions/{FunctionName}/url");
+    b.p("FunctionName", () => input.FunctionName, "{FunctionName}", false);
     const query = map({
-        Qualifier: [, input.Qualifier],
+        [_Q]: [, input[_Q]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -1513,16 +982,8 @@ export const se_UpdateFunctionUrlConfigCommand = async (input, context) => {
         Cors: (_) => _json(_),
         InvokeMode: [],
     }));
-    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 de_AddLayerVersionPermissionCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -3132,9 +2593,9 @@ export const de_InvokeCommand = async (output, context) => {
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
-        FunctionError: [, output.headers["x-amz-function-error"]],
-        LogResult: [, output.headers["x-amz-log-result"]],
-        ExecutedVersion: [, output.headers["x-amz-executed-version"]],
+        [_FE]: [, output.headers[_xafe]],
+        [_LR]: [, output.headers[_xalr]],
+        [_EV]: [, output.headers[_xaev]],
     });
     const data = await collectBody(output.body, context);
     contents.Payload = data;
@@ -3299,8 +2760,8 @@ export const de_InvokeWithResponseStreamCommand = async (output, context) => {
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
-        ExecutedVersion: [, output.headers["x-amz-executed-version"]],
-        ResponseStreamContentType: [, output.headers["content-type"]],
+        [_EV]: [, output.headers[_xaev]],
+        [_RSCT]: [, output.headers[_ct]],
     });
     const data = output.body;
     contents.EventStream = de_InvokeWithResponseStreamResponseEvent(data, context);
@@ -5419,7 +4880,7 @@ const de_SubnetIPAddressLimitReachedExceptionRes = 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, {
@@ -5605,6 +5066,37 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _A = "Arn";
+const _CA = "CompatibleArchitecture";
+const _CC = "ClientContext";
+const _CR = "CompatibleRuntime";
+const _ESA = "EventSourceArn";
+const _EV = "ExecutedVersion";
+const _FE = "FunctionError";
+const _FN = "FunctionName";
+const _FV = "FunctionVersion";
+const _IT = "InvocationType";
+const _L = "List";
+const _LR = "LogResult";
+const _LT = "LogType";
+const _M = "Marker";
+const _MI = "MaxItems";
+const _MR = "MasterRegion";
+const _Q = "Qualifier";
+const _RI = "RevisionId";
+const _RSCT = "ResponseStreamContentType";
+const _TK = "TagKeys";
+const _ct = "content-type";
+const _f = "find";
+const _rAS = "retryAfterSeconds";
+const _ra = "retry-after";
+const _tK = "tagKeys";
+const _xacc = "x-amz-client-context";
+const _xaev = "x-amz-executed-version";
+const _xafe = "x-amz-function-error";
+const _xait = "x-amz-invocation-type";
+const _xalr = "x-amz-log-result";
+const _xalt = "x-amz-log-type";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);