@aws-sdk/client-mediaconnect 3.476.0 → 3.478.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,139 +1,97 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, 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, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { MediaConnectServiceException as __BaseException } from "../models/MediaConnectServiceException";
 import { AddFlowOutputs420Exception, BadRequestException, ConflictException, CreateBridge420Exception, CreateFlow420Exception, CreateGateway420Exception, ForbiddenException, GrantFlowEntitlements420Exception, InternalServerErrorException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, } from "../models/models_0";
 export const se_AddBridgeOutputsCommand = 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 || ""}` + "/v1/bridges/{BridgeArn}/outputs";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.bp("/v1/bridges/{BridgeArn}/outputs");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         outputs: [, (_) => se___listOfAddBridgeOutputRequest(_, context), `Outputs`],
     }));
-    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_AddBridgeSourcesCommand = 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 || ""}` + "/v1/bridges/{BridgeArn}/sources";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.bp("/v1/bridges/{BridgeArn}/sources");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
     }));
-    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_AddFlowMediaStreamsCommand = 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 || ""}` + "/v1/flows/{FlowArn}/mediaStreams";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}/mediaStreams");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         mediaStreams: [, (_) => se___listOfAddMediaStreamRequest(_, context), `MediaStreams`],
     }));
-    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_AddFlowOutputsCommand = 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 || ""}` + "/v1/flows/{FlowArn}/outputs";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}/outputs");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         outputs: [, (_) => se___listOfAddOutputRequest(_, context), `Outputs`],
     }));
-    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_AddFlowSourcesCommand = 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 || ""}` + "/v1/flows/{FlowArn}/source";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}/source");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
     }));
-    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_AddFlowVpcInterfacesCommand = 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 || ""}` + "/v1/flows/{FlowArn}/vpcInterfaces";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}/vpcInterfaces");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
     }));
-    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_CreateBridgeCommand = 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 || ""}` + "/v1/bridges";
+    b.bp("/v1/bridges");
     let body;
     body = JSON.stringify(take(input, {
         egressGatewayBridge: [, (_) => se_AddEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
@@ -144,22 +102,15 @@ export const se_CreateBridgeCommand = async (input, context) => {
         sourceFailoverConfig: [, (_) => se_FailoverConfig(_, context), `SourceFailoverConfig`],
         sources: [, (_) => se___listOfAddBridgeSourceRequest(_, context), `Sources`],
     }));
-    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_CreateFlowCommand = 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 || ""}` + "/v1/flows";
+    b.bp("/v1/flows");
     let body;
     body = JSON.stringify(take(input, {
         availabilityZone: [, , `AvailabilityZone`],
@@ -173,727 +124,442 @@ export const se_CreateFlowCommand = async (input, context) => {
         sources: [, (_) => se___listOfSetSourceRequest(_, context), `Sources`],
         vpcInterfaces: [, (_) => se___listOfVpcInterfaceRequest(_, context), `VpcInterfaces`],
     }));
-    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_CreateGatewayCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways";
+    b.bp("/v1/gateways");
     let body;
     body = JSON.stringify(take(input, {
         egressCidrBlocks: [, (_) => _json(_), `EgressCidrBlocks`],
         name: [, , `Name`],
         networks: [, (_) => se___listOfGatewayNetwork(_, context), `Networks`],
     }));
-    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_DeleteBridgeCommand = 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 || ""}` + "/v1/bridges/{BridgeArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.bp("/v1/bridges/{BridgeArn}");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", 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_DeleteFlowCommand = 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 || ""}` + "/v1/flows/{FlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", 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_DeleteGatewayCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways/{GatewayArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
+    b.bp("/v1/gateways/{GatewayArn}");
+    b.p("GatewayArn", () => input.GatewayArn, "{GatewayArn}", 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_DeregisterGatewayInstanceCommand = 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 || ""}` +
-        "/v1/gateway-instances/{GatewayInstanceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
+    b.bp("/v1/gateway-instances/{GatewayInstanceArn}");
+    b.p("GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
     const query = map({
-        force: [() => input.Force !== void 0, () => input.Force.toString()],
+        [_f]: [() => input.Force !== void 0, () => input[_F].toString()],
     });
     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_DescribeBridgeCommand = 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 || ""}` + "/v1/bridges/{BridgeArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.bp("/v1/bridges/{BridgeArn}");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", 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_DescribeFlowCommand = 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 || ""}` + "/v1/flows/{FlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", 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_DescribeGatewayCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways/{GatewayArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayArn", () => input.GatewayArn, "{GatewayArn}", false);
+    b.bp("/v1/gateways/{GatewayArn}");
+    b.p("GatewayArn", () => input.GatewayArn, "{GatewayArn}", 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_DescribeGatewayInstanceCommand = 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 || ""}` +
-        "/v1/gateway-instances/{GatewayInstanceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
+    b.bp("/v1/gateway-instances/{GatewayInstanceArn}");
+    b.p("GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", 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_DescribeOfferingCommand = 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 || ""}` + "/v1/offerings/{OfferingArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
+    b.bp("/v1/offerings/{OfferingArn}");
+    b.p("OfferingArn", () => input.OfferingArn, "{OfferingArn}", 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_DescribeReservationCommand = 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 || ""}` + "/v1/reservations/{ReservationArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ReservationArn", () => input.ReservationArn, "{ReservationArn}", false);
+    b.bp("/v1/reservations/{ReservationArn}");
+    b.p("ReservationArn", () => input.ReservationArn, "{ReservationArn}", 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_GrantFlowEntitlementsCommand = 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 || ""}` + "/v1/flows/{FlowArn}/entitlements";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}/entitlements");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         entitlements: [, (_) => se___listOfGrantEntitlementRequest(_, context), `Entitlements`],
     }));
-    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_ListBridgesCommand = 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 || ""}` + "/v1/bridges";
+    b.bp("/v1/bridges");
     const query = map({
-        filterArn: [, input.FilterArn],
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
+        [_fA]: [, input[_FA]],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
     });
     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_ListEntitlementsCommand = 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 || ""}` + "/v1/entitlements";
+    b.bp("/v1/entitlements");
     const query = map({
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
     });
     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_ListFlowsCommand = 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 || ""}` + "/v1/flows";
+    b.bp("/v1/flows");
     const query = map({
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
     });
     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_ListGatewayInstancesCommand = 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 || ""}` + "/v1/gateway-instances";
+    b.bp("/v1/gateway-instances");
     const query = map({
-        filterArn: [, input.FilterArn],
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
+        [_fA]: [, input[_FA]],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
     });
     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_ListGatewaysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/gateways";
+    b.bp("/v1/gateways");
     const query = map({
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
     });
     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_ListOfferingsCommand = 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 || ""}` + "/v1/offerings";
+    b.bp("/v1/offerings");
     const query = map({
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
     });
     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_ListReservationsCommand = 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 || ""}` + "/v1/reservations";
+    b.bp("/v1/reservations");
     const query = map({
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
     });
     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_ListTagsForResourceCommand = 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);
     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_PurchaseOfferingCommand = 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 || ""}` + "/v1/offerings/{OfferingArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
+    b.bp("/v1/offerings/{OfferingArn}");
+    b.p("OfferingArn", () => input.OfferingArn, "{OfferingArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         reservationName: [, , `ReservationName`],
         start: [, , `Start`],
     }));
-    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_RemoveBridgeOutputCommand = 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 || ""}` +
-        "/v1/bridges/{BridgeArn}/outputs/{OutputName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "OutputName", () => input.OutputName, "{OutputName}", false);
+    b.bp("/v1/bridges/{BridgeArn}/outputs/{OutputName}");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.p("OutputName", () => input.OutputName, "{OutputName}", 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_RemoveBridgeSourceCommand = 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 || ""}` +
-        "/v1/bridges/{BridgeArn}/sources/{SourceName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "SourceName", () => input.SourceName, "{SourceName}", false);
+    b.bp("/v1/bridges/{BridgeArn}/sources/{SourceName}");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.p("SourceName", () => input.SourceName, "{SourceName}", 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_RemoveFlowMediaStreamCommand = 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 || ""}` +
-        "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
+    b.bp("/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.p("MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", 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_RemoveFlowOutputCommand = 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 || ""}` + "/v1/flows/{FlowArn}/outputs/{OutputArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "OutputArn", () => input.OutputArn, "{OutputArn}", false);
+    b.bp("/v1/flows/{FlowArn}/outputs/{OutputArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.p("OutputArn", () => input.OutputArn, "{OutputArn}", 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_RemoveFlowSourceCommand = 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 || ""}` + "/v1/flows/{FlowArn}/source/{SourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "SourceArn", () => input.SourceArn, "{SourceArn}", false);
+    b.bp("/v1/flows/{FlowArn}/source/{SourceArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.p("SourceArn", () => input.SourceArn, "{SourceArn}", 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_RemoveFlowVpcInterfaceCommand = 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 || ""}` +
-        "/v1/flows/{FlowArn}/vpcInterfaces/{VpcInterfaceName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "VpcInterfaceName", () => input.VpcInterfaceName, "{VpcInterfaceName}", false);
+    b.bp("/v1/flows/{FlowArn}/vpcInterfaces/{VpcInterfaceName}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.p("VpcInterfaceName", () => input.VpcInterfaceName, "{VpcInterfaceName}", 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_RevokeFlowEntitlementCommand = 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 || ""}` +
-        "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}/entitlements/{EntitlementArn}");
+    b.p("EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", 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_StartFlowCommand = 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 || ""}` + "/v1/flows/start/{FlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/start/{FlowArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
-    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_StopFlowCommand = 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 || ""}` + "/v1/flows/stop/{FlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/stop/{FlowArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
-    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_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(_), `Tags`],
     }));
-    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_UpdateBridgeCommand = 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 || ""}` + "/v1/bridges/{BridgeArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.bp("/v1/bridges/{BridgeArn}");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         egressGatewayBridge: [, (_) => se_UpdateEgressGatewayBridgeRequest(_, context), `EgressGatewayBridge`],
         ingressGatewayBridge: [, (_) => se_UpdateIngressGatewayBridgeRequest(_, context), `IngressGatewayBridge`],
         sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
     }));
-    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_UpdateBridgeOutputCommand = 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 || ""}` +
-        "/v1/bridges/{BridgeArn}/outputs/{OutputName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "OutputName", () => input.OutputName, "{OutputName}", false);
+    b.bp("/v1/bridges/{BridgeArn}/outputs/{OutputName}");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.p("OutputName", () => input.OutputName, "{OutputName}", false);
     let body;
     body = JSON.stringify(take(input, {
         networkOutput: [, (_) => se_UpdateBridgeNetworkOutputRequest(_, context), `NetworkOutput`],
     }));
-    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_UpdateBridgeSourceCommand = 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 || ""}` +
-        "/v1/bridges/{BridgeArn}/sources/{SourceName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "SourceName", () => input.SourceName, "{SourceName}", false);
+    b.bp("/v1/bridges/{BridgeArn}/sources/{SourceName}");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.p("SourceName", () => input.SourceName, "{SourceName}", false);
     let body;
     body = JSON.stringify(take(input, {
         flowSource: [, (_) => se_UpdateBridgeFlowSourceRequest(_, context), `FlowSource`],
         networkSource: [, (_) => se_UpdateBridgeNetworkSourceRequest(_, context), `NetworkSource`],
     }));
-    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_UpdateBridgeStateCommand = 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 || ""}` + "/v1/bridges/{BridgeArn}/state";
-    resolvedPath = __resolvedPath(resolvedPath, input, "BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
+    b.bp("/v1/bridges/{BridgeArn}/state");
+    b.p("BridgeArn", () => input.BridgeArn, "{BridgeArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         desiredState: [, , `DesiredState`],
     }));
-    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_UpdateFlowCommand = 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 || ""}` + "/v1/flows/{FlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         maintenance: [, (_) => se_UpdateMaintenance(_, context), `Maintenance`],
         sourceFailoverConfig: [, (_) => se_UpdateFailoverConfig(_, context), `SourceFailoverConfig`],
     }));
-    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_UpdateFlowEntitlementCommand = 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 || ""}` +
-        "/v1/flows/{FlowArn}/entitlements/{EntitlementArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.bp("/v1/flows/{FlowArn}/entitlements/{EntitlementArn}");
+    b.p("EntitlementArn", () => input.EntitlementArn, "{EntitlementArn}", false);
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [, , `Description`],
@@ -901,25 +567,17 @@ export const se_UpdateFlowEntitlementCommand = async (input, context) => {
         entitlementStatus: [, , `EntitlementStatus`],
         subscribers: [, (_) => _json(_), `Subscribers`],
     }));
-    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_UpdateFlowMediaStreamCommand = 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 || ""}` +
-        "/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
+    b.bp("/v1/flows/{FlowArn}/mediaStreams/{MediaStreamName}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.p("MediaStreamName", () => input.MediaStreamName, "{MediaStreamName}", false);
     let body;
     body = JSON.stringify(take(input, {
         attributes: [, (_) => se_MediaStreamAttributesRequest(_, context), `Attributes`],
@@ -928,24 +586,17 @@ export const se_UpdateFlowMediaStreamCommand = async (input, context) => {
         mediaStreamType: [, , `MediaStreamType`],
         videoFormat: [, , `VideoFormat`],
     }));
-    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_UpdateFlowOutputCommand = 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 || ""}` + "/v1/flows/{FlowArn}/outputs/{OutputArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "OutputArn", () => input.OutputArn, "{OutputArn}", false);
+    b.bp("/v1/flows/{FlowArn}/outputs/{OutputArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.p("OutputArn", () => input.OutputArn, "{OutputArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         cidrAllowList: [, (_) => _json(_), `CidrAllowList`],
@@ -968,24 +619,17 @@ export const se_UpdateFlowOutputCommand = async (input, context) => {
         streamId: [, , `StreamId`],
         vpcInterfaceAttachment: [, (_) => se_VpcInterfaceAttachment(_, context), `VpcInterfaceAttachment`],
     }));
-    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_UpdateFlowSourceCommand = 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 || ""}` + "/v1/flows/{FlowArn}/source/{SourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "FlowArn", () => input.FlowArn, "{FlowArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "SourceArn", () => input.SourceArn, "{SourceArn}", false);
+    b.bp("/v1/flows/{FlowArn}/source/{SourceArn}");
+    b.p("FlowArn", () => input.FlowArn, "{FlowArn}", false);
+    b.p("SourceArn", () => input.SourceArn, "{SourceArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         decryption: [, (_) => se_UpdateEncryption(_, context), `Decryption`],
@@ -1011,37 +655,22 @@ export const se_UpdateFlowSourceCommand = async (input, context) => {
         vpcInterfaceName: [, , `VpcInterfaceName`],
         whitelistCidr: [, , `WhitelistCidr`],
     }));
-    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_UpdateGatewayInstanceCommand = 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 || ""}` +
-        "/v1/gateway-instances/{GatewayInstanceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
+    b.bp("/v1/gateway-instances/{GatewayInstanceArn}");
+    b.p("GatewayInstanceArn", () => input.GatewayInstanceArn, "{GatewayInstanceArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         bridgePlacement: [, , `BridgePlacement`],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const de_AddBridgeOutputsCommand = async (output, context) => {
     if (output.statusCode !== 202 && output.statusCode >= 300) {
@@ -4590,6 +4219,16 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _F = "Force";
+const _FA = "FilterArn";
+const _MR = "MaxResults";
+const _NT = "NextToken";
+const _TK = "TagKeys";
+const _f = "force";
+const _fA = "filterArn";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _tK = "tagKeys";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);