@aws-sdk/client-medialive 3.476.0 → 3.478.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,30 +1,23 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, parseRfc7231DateTime as __parseRfc7231DateTime, resolvedPath as __resolvedPath, serializeFloat as __serializeFloat, strictParseLong as __strictParseLong, take, withBaseException, } from "@smithy/smithy-client";
+import { requestBuilder as rb } from "@smithy/core";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, parseRfc7231DateTime as __parseRfc7231DateTime, serializeFloat as __serializeFloat, strictParseLong as __strictParseLong, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { MediaLiveServiceException as __BaseException } from "../models/MediaLiveServiceException";
 import { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, InternalServerErrorException, NotFoundException, TooManyRequestsException, UnprocessableEntityException, } from "../models/models_1";
 export const se_AcceptInputDeviceTransferCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}/accept";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/accept");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_BatchDeleteCommand = 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 || ""}` + "/prod/batch/delete";
+    b.bp("/prod/batch/delete");
     let body;
     body = JSON.stringify(take(input, {
         channelIds: [, (_) => _json(_), `ChannelIds`],
@@ -32,122 +25,80 @@ export const se_BatchDeleteCommand = async (input, context) => {
         inputSecurityGroupIds: [, (_) => _json(_), `InputSecurityGroupIds`],
         multiplexIds: [, (_) => _json(_), `MultiplexIds`],
     }));
-    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_BatchStartCommand = 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 || ""}` + "/prod/batch/start";
+    b.bp("/prod/batch/start");
     let body;
     body = JSON.stringify(take(input, {
         channelIds: [, (_) => _json(_), `ChannelIds`],
         multiplexIds: [, (_) => _json(_), `MultiplexIds`],
     }));
-    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_BatchStopCommand = 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 || ""}` + "/prod/batch/stop";
+    b.bp("/prod/batch/stop");
     let body;
     body = JSON.stringify(take(input, {
         channelIds: [, (_) => _json(_), `ChannelIds`],
         multiplexIds: [, (_) => _json(_), `MultiplexIds`],
     }));
-    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_BatchUpdateScheduleCommand = 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 || ""}` + "/prod/channels/{ChannelId}/schedule";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}/schedule");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
     let body;
     body = JSON.stringify(take(input, {
         creates: [, (_) => se_BatchScheduleActionCreateRequest(_, context), `Creates`],
         deletes: [, (_) => se_BatchScheduleActionDeleteRequest(_, context), `Deletes`],
     }));
-    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_CancelInputDeviceTransferCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}/cancel";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/cancel");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_ClaimDeviceCommand = 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 || ""}` + "/prod/claimDevice";
+    b.bp("/prod/claimDevice");
     let body;
     body = JSON.stringify(take(input, {
         id: [, , `Id`],
     }));
-    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_CreateChannelCommand = 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 || ""}` + "/prod/channels";
+    b.bp("/prod/channels");
     let body;
     body = JSON.stringify(take(input, {
         cdiInputSpecification: [, (_) => se_CdiInputSpecification(_, context), `CdiInputSpecification`],
@@ -165,22 +116,15 @@ export const se_CreateChannelCommand = async (input, context) => {
         tags: [, (_) => _json(_), `Tags`],
         vpc: [, (_) => se_VpcOutputSettings(_, context), `Vpc`],
     }));
-    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_CreateInputCommand = 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 || ""}` + "/prod/inputs";
+    b.bp("/prod/inputs");
     let body;
     body = JSON.stringify(take(input, {
         destinations: [, (_) => se___listOfInputDestinationRequest(_, context), `Destinations`],
@@ -195,43 +139,29 @@ export const se_CreateInputCommand = async (input, context) => {
         type: [, , `Type`],
         vpc: [, (_) => se_InputVpcRequest(_, context), `Vpc`],
     }));
-    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_CreateInputSecurityGroupCommand = 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 || ""}` + "/prod/inputSecurityGroups";
+    b.bp("/prod/inputSecurityGroups");
     let body;
     body = JSON.stringify(take(input, {
         tags: [, (_) => _json(_), `Tags`],
         whitelistRules: [, (_) => se___listOfInputWhitelistRuleCidr(_, context), `WhitelistRules`],
     }));
-    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_CreateMultiplexCommand = 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 || ""}` + "/prod/multiplexes";
+    b.bp("/prod/multiplexes");
     let body;
     body = JSON.stringify(take(input, {
         availabilityZones: [, (_) => _json(_), `AvailabilityZones`],
@@ -240,653 +170,398 @@ export const se_CreateMultiplexCommand = async (input, context) => {
         requestId: [true, (_) => _ ?? generateIdempotencyToken(), `RequestId`],
         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_CreateMultiplexProgramCommand = 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 || ""}` + "/prod/multiplexes/{MultiplexId}/programs";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}/programs");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
     let body;
     body = JSON.stringify(take(input, {
         multiplexProgramSettings: [, (_) => se_MultiplexProgramSettings(_, context), `MultiplexProgramSettings`],
         programName: [, , `ProgramName`],
         requestId: [true, (_) => _ ?? generateIdempotencyToken(), `RequestId`],
     }));
-    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_CreatePartnerInputCommand = 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 || ""}` + "/prod/inputs/{InputId}/partners";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
+    b.bp("/prod/inputs/{InputId}/partners");
+    b.p("InputId", () => input.InputId, "{InputId}", false);
     let body;
     body = JSON.stringify(take(input, {
         requestId: [true, (_) => _ ?? generateIdempotencyToken(), `RequestId`],
         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_CreateTagsCommand = 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 || ""}` + "/prod/tags/{ResourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    b.bp("/prod/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_DeleteChannelCommand = 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 || ""}` + "/prod/channels/{ChannelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", 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_DeleteInputCommand = 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 || ""}` + "/prod/inputs/{InputId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
+    b.bp("/prod/inputs/{InputId}");
+    b.p("InputId", () => input.InputId, "{InputId}", 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_DeleteInputSecurityGroupCommand = 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 || ""}` +
-        "/prod/inputSecurityGroups/{InputSecurityGroupId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
+    b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
+    b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", 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_DeleteMultiplexCommand = 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 || ""}` + "/prod/multiplexes/{MultiplexId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", 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_DeleteMultiplexProgramCommand = 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 || ""}` +
-        "/prod/multiplexes/{MultiplexId}/programs/{ProgramName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "ProgramName", () => input.ProgramName, "{ProgramName}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}/programs/{ProgramName}");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.p("ProgramName", () => input.ProgramName, "{ProgramName}", 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_DeleteReservationCommand = 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 || ""}` + "/prod/reservations/{ReservationId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ReservationId", () => input.ReservationId, "{ReservationId}", false);
+    b.bp("/prod/reservations/{ReservationId}");
+    b.p("ReservationId", () => input.ReservationId, "{ReservationId}", 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_DeleteScheduleCommand = 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 || ""}` + "/prod/channels/{ChannelId}/schedule";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}/schedule");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", 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_DeleteTagsCommand = 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 || ""}` + "/prod/tags/{ResourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    b.bp("/prod/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_DescribeAccountConfigurationCommand = 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 || ""}` + "/prod/accountConfiguration";
+    b.bp("/prod/accountConfiguration");
     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_DescribeChannelCommand = 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 || ""}` + "/prod/channels/{ChannelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", 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_DescribeInputCommand = 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 || ""}` + "/prod/inputs/{InputId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
+    b.bp("/prod/inputs/{InputId}");
+    b.p("InputId", () => input.InputId, "{InputId}", 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_DescribeInputDeviceCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_DescribeInputDeviceThumbnailCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        accept: input.Accept,
+        [_a]: input[_A],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/prod/inputDevices/{InputDeviceId}/thumbnailData";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/thumbnailData");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_DescribeInputSecurityGroupCommand = 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 || ""}` +
-        "/prod/inputSecurityGroups/{InputSecurityGroupId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
+    b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
+    b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", 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_DescribeMultiplexCommand = 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 || ""}` + "/prod/multiplexes/{MultiplexId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", 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_DescribeMultiplexProgramCommand = 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 || ""}` +
-        "/prod/multiplexes/{MultiplexId}/programs/{ProgramName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "ProgramName", () => input.ProgramName, "{ProgramName}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}/programs/{ProgramName}");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.p("ProgramName", () => input.ProgramName, "{ProgramName}", 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 || ""}` + "/prod/offerings/{OfferingId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "OfferingId", () => input.OfferingId, "{OfferingId}", false);
+    b.bp("/prod/offerings/{OfferingId}");
+    b.p("OfferingId", () => input.OfferingId, "{OfferingId}", 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 || ""}` + "/prod/reservations/{ReservationId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ReservationId", () => input.ReservationId, "{ReservationId}", false);
+    b.bp("/prod/reservations/{ReservationId}");
+    b.p("ReservationId", () => input.ReservationId, "{ReservationId}", 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_DescribeScheduleCommand = 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 || ""}` + "/prod/channels/{ChannelId}/schedule";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}/schedule");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
     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_DescribeThumbnailsCommand = 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 || ""}` + "/prod/channels/{ChannelId}/thumbnails";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}/thumbnails");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
     const query = map({
-        pipelineId: [, __expectNonNull(input.PipelineId, `PipelineId`)],
-        thumbnailType: [, __expectNonNull(input.ThumbnailType, `ThumbnailType`)],
+        [_pI]: [, __expectNonNull(input[_PI], `PipelineId`)],
+        [_tT]: [, __expectNonNull(input[_TT], `ThumbnailType`)],
     });
     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_ListChannelsCommand = 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 || ""}` + "/prod/channels";
+    b.bp("/prod/channels");
     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_ListInputDevicesCommand = 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 || ""}` + "/prod/inputDevices";
+    b.bp("/prod/inputDevices");
     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_ListInputDeviceTransfersCommand = 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 || ""}` + "/prod/inputDeviceTransfers";
+    b.bp("/prod/inputDeviceTransfers");
     const query = map({
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        nextToken: [, input.NextToken],
-        transferType: [, __expectNonNull(input.TransferType, `TransferType`)],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nT]: [, input[_NT]],
+        [_tTr]: [, __expectNonNull(input[_TTr], `TransferType`)],
     });
     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_ListInputsCommand = 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 || ""}` + "/prod/inputs";
+    b.bp("/prod/inputs");
     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_ListInputSecurityGroupsCommand = 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 || ""}` + "/prod/inputSecurityGroups";
+    b.bp("/prod/inputSecurityGroups");
     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_ListMultiplexesCommand = 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 || ""}` + "/prod/multiplexes";
+    b.bp("/prod/multiplexes");
     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_ListMultiplexProgramsCommand = 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 || ""}` + "/prod/multiplexes/{MultiplexId}/programs";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}/programs");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
     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 || ""}` + "/prod/offerings";
+    b.bp("/prod/offerings");
     const query = map({
-        channelClass: [, input.ChannelClass],
-        channelConfiguration: [, input.ChannelConfiguration],
-        codec: [, input.Codec],
-        duration: [, input.Duration],
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        maximumBitrate: [, input.MaximumBitrate],
-        maximumFramerate: [, input.MaximumFramerate],
-        nextToken: [, input.NextToken],
-        resolution: [, input.Resolution],
-        resourceType: [, input.ResourceType],
-        specialFeature: [, input.SpecialFeature],
-        videoQuality: [, input.VideoQuality],
+        [_cC]: [, input[_CC]],
+        [_cCh]: [, input[_CCh]],
+        [_c]: [, input[_C]],
+        [_d]: [, input[_D]],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_mB]: [, input[_MB]],
+        [_mF]: [, input[_MF]],
+        [_nT]: [, input[_NT]],
+        [_r]: [, input[_R]],
+        [_rT]: [, input[_RT]],
+        [_sF]: [, input[_SF]],
+        [_vQ]: [, input[_VQ]],
     });
     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 || ""}` + "/prod/reservations";
+    b.bp("/prod/reservations");
     const query = map({
-        channelClass: [, input.ChannelClass],
-        codec: [, input.Codec],
-        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        maximumBitrate: [, input.MaximumBitrate],
-        maximumFramerate: [, input.MaximumFramerate],
-        nextToken: [, input.NextToken],
-        resolution: [, input.Resolution],
-        resourceType: [, input.ResourceType],
-        specialFeature: [, input.SpecialFeature],
-        videoQuality: [, input.VideoQuality],
+        [_cC]: [, input[_CC]],
+        [_c]: [, input[_C]],
+        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_mB]: [, input[_MB]],
+        [_mF]: [, input[_MF]],
+        [_nT]: [, input[_NT]],
+        [_r]: [, input[_R]],
+        [_rT]: [, input[_RT]],
+        [_sF]: [, input[_SF]],
+        [_vQ]: [, input[_VQ]],
     });
     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 || ""}` + "/prod/tags/{ResourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    b.bp("/prod/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 || ""}` + "/prod/offerings/{OfferingId}/purchase";
-    resolvedPath = __resolvedPath(resolvedPath, input, "OfferingId", () => input.OfferingId, "{OfferingId}", false);
+    b.bp("/prod/offerings/{OfferingId}/purchase");
+    b.p("OfferingId", () => input.OfferingId, "{OfferingId}", false);
     let body;
     body = JSON.stringify(take(input, {
         count: [, , `Count`],
@@ -896,217 +571,131 @@ export const se_PurchaseOfferingCommand = async (input, context) => {
         start: [, , `Start`],
         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_RebootInputDeviceCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}/reboot";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/reboot");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
     let body;
     body = JSON.stringify(take(input, {
         force: [, , `Force`],
     }));
-    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_RejectInputDeviceTransferCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}/reject";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/reject");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_StartChannelCommand = 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 || ""}` + "/prod/channels/{ChannelId}/start";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}/start");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", 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_StartInputDeviceCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}/start";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/start");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_StartInputDeviceMaintenanceWindowCommand = 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 || ""}` +
-        "/prod/inputDevices/{InputDeviceId}/startInputDeviceMaintenanceWindow";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/startInputDeviceMaintenanceWindow");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_StartMultiplexCommand = 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 || ""}` + "/prod/multiplexes/{MultiplexId}/start";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}/start");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", 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_StopChannelCommand = 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 || ""}` + "/prod/channels/{ChannelId}/stop";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}/stop");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", 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_StopInputDeviceCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}/stop";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/stop");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", 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_StopMultiplexCommand = 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 || ""}` + "/prod/multiplexes/{MultiplexId}/stop";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}/stop");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", 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_TransferInputDeviceCommand = 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 || ""}` +
-        "/prod/inputDevices/{InputDeviceId}/transfer";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}/transfer");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
     let body;
     body = JSON.stringify(take(input, {
         targetCustomerId: [, , `TargetCustomerId`],
         targetRegion: [, , `TargetRegion`],
         transferMessage: [, , `TransferMessage`],
     }));
-    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_UpdateAccountConfigurationCommand = 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 || ""}` + "/prod/accountConfiguration";
+    b.bp("/prod/accountConfiguration");
     let body;
     body = JSON.stringify(take(input, {
         accountConfiguration: [, (_) => se_AccountConfiguration(_, context), `AccountConfiguration`],
     }));
-    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_UpdateChannelCommand = 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 || ""}` + "/prod/channels/{ChannelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
     let body;
     body = JSON.stringify(take(input, {
         cdiInputSpecification: [, (_) => se_CdiInputSpecification(_, context), `CdiInputSpecification`],
@@ -1119,45 +708,31 @@ export const se_UpdateChannelCommand = async (input, context) => {
         name: [, , `Name`],
         roleArn: [, , `RoleArn`],
     }));
-    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_UpdateChannelClassCommand = 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 || ""}` + "/prod/channels/{ChannelId}/channelClass";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelId", () => input.ChannelId, "{ChannelId}", false);
+    b.bp("/prod/channels/{ChannelId}/channelClass");
+    b.p("ChannelId", () => input.ChannelId, "{ChannelId}", false);
     let body;
     body = JSON.stringify(take(input, {
         channelClass: [, , `ChannelClass`],
         destinations: [, (_) => se___listOfOutputDestination(_, context), `Destinations`],
     }));
-    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_UpdateInputCommand = 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 || ""}` + "/prod/inputs/{InputId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputId", () => input.InputId, "{InputId}", false);
+    b.bp("/prod/inputs/{InputId}");
+    b.p("InputId", () => input.InputId, "{InputId}", false);
     let body;
     body = JSON.stringify(take(input, {
         destinations: [, (_) => se___listOfInputDestinationRequest(_, context), `Destinations`],
@@ -1168,23 +743,16 @@ export const se_UpdateInputCommand = async (input, context) => {
         roleArn: [, , `RoleArn`],
         sources: [, (_) => se___listOfInputSourceRequest(_, context), `Sources`],
     }));
-    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_UpdateInputDeviceCommand = 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 || ""}` + "/prod/inputDevices/{InputDeviceId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+    b.bp("/prod/inputDevices/{InputDeviceId}");
+    b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
     let body;
     body = JSON.stringify(take(input, {
         availabilityZone: [, , `AvailabilityZone`],
@@ -1192,105 +760,68 @@ export const se_UpdateInputDeviceCommand = async (input, context) => {
         name: [, , `Name`],
         uhdDeviceSettings: [, (_) => se_InputDeviceConfigurableSettings(_, context), `UhdDeviceSettings`],
     }));
-    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_UpdateInputSecurityGroupCommand = 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 || ""}` +
-        "/prod/inputSecurityGroups/{InputSecurityGroupId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
+    b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
+    b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
     let body;
     body = JSON.stringify(take(input, {
         tags: [, (_) => _json(_), `Tags`],
         whitelistRules: [, (_) => se___listOfInputWhitelistRuleCidr(_, context), `WhitelistRules`],
     }));
-    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_UpdateMultiplexCommand = 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 || ""}` + "/prod/multiplexes/{MultiplexId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
     let body;
     body = JSON.stringify(take(input, {
         multiplexSettings: [, (_) => se_MultiplexSettings(_, context), `MultiplexSettings`],
         name: [, , `Name`],
     }));
-    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_UpdateMultiplexProgramCommand = 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 || ""}` +
-        "/prod/multiplexes/{MultiplexId}/programs/{ProgramName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "ProgramName", () => input.ProgramName, "{ProgramName}", false);
+    b.bp("/prod/multiplexes/{MultiplexId}/programs/{ProgramName}");
+    b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+    b.p("ProgramName", () => input.ProgramName, "{ProgramName}", false);
     let body;
     body = JSON.stringify(take(input, {
         multiplexProgramSettings: [, (_) => se_MultiplexProgramSettings(_, context), `MultiplexProgramSettings`],
     }));
-    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_UpdateReservationCommand = 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 || ""}` + "/prod/reservations/{ReservationId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ReservationId", () => input.ReservationId, "{ReservationId}", false);
+    b.bp("/prod/reservations/{ReservationId}");
+    b.p("ReservationId", () => input.ReservationId, "{ReservationId}", false);
     let body;
     body = JSON.stringify(take(input, {
         name: [, , `Name`],
         renewalSettings: [, (_) => se_RenewalSettings(_, context), `RenewalSettings`],
     }));
-    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_AcceptInputDeviceTransferCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2712,16 +2243,10 @@ export const de_DescribeInputDeviceThumbnailCommand = async (output, context) =>
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
-        ContentType: [, output.headers["content-type"]],
-        ContentLength: [
-            () => void 0 !== output.headers["content-length"],
-            () => __strictParseLong(output.headers["content-length"]),
-        ],
-        ETag: [, output.headers["etag"]],
-        LastModified: [
-            () => void 0 !== output.headers["last-modified"],
-            () => __expectNonNull(__parseRfc7231DateTime(output.headers["last-modified"])),
-        ],
+        [_CT]: [, output.headers[_ct]],
+        [_CL]: [() => void 0 !== output.headers[_cl], () => __strictParseLong(output.headers[_cl])],
+        [_ET]: [, output.headers[_e]],
+        [_LM]: [() => void 0 !== output.headers[_lm], () => __expectNonNull(__parseRfc7231DateTime(output.headers[_lm]))],
     });
     const data = output.body;
     context.sdkStreamMixin(data);
@@ -9043,6 +8568,48 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _A = "Accept";
+const _C = "Codec";
+const _CC = "ChannelClass";
+const _CCh = "ChannelConfiguration";
+const _CL = "ContentLength";
+const _CT = "ContentType";
+const _D = "Duration";
+const _ET = "ETag";
+const _LM = "LastModified";
+const _MB = "MaximumBitrate";
+const _MF = "MaximumFramerate";
+const _MR = "MaxResults";
+const _NT = "NextToken";
+const _PI = "PipelineId";
+const _R = "Resolution";
+const _RT = "ResourceType";
+const _SF = "SpecialFeature";
+const _TK = "TagKeys";
+const _TT = "ThumbnailType";
+const _TTr = "TransferType";
+const _VQ = "VideoQuality";
+const _a = "accept";
+const _c = "codec";
+const _cC = "channelClass";
+const _cCh = "channelConfiguration";
+const _cl = "content-length";
+const _ct = "content-type";
+const _d = "duration";
+const _e = "etag";
+const _lm = "last-modified";
+const _mB = "maximumBitrate";
+const _mF = "maximumFramerate";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _pI = "pipelineId";
+const _r = "resolution";
+const _rT = "resourceType";
+const _sF = "specialFeature";
+const _tK = "tagKeys";
+const _tT = "thumbnailType";
+const _tTr = "transferType";
+const _vQ = "videoQuality";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);