@aws-sdk/client-chime-sdk-messaging 3.476.0 → 3.478.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,40 +1,33 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
+import { requestBuilder as rb } from "@smithy/core";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { ChimeSDKMessagingServiceException as __BaseException } from "../models/ChimeSDKMessagingServiceException";
 import { BadRequestException, ConflictException, ForbiddenException, NotFoundException, ResourceLimitExceededException, ServiceFailureException, ServiceUnavailableException, ThrottledClientException, UnauthorizedClientException, } from "../models/models_0";
 export const se_AssociateChannelFlowCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/channel-flow";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/channel-flow");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         ChannelFlowArn: [],
     }));
-    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_BatchCreateChannelMembershipCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/memberships";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/memberships");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        operation: [, "batch-create"],
+        [_o]: [, "batch-create"],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -42,26 +35,18 @@ export const se_BatchCreateChannelMembershipCommand = async (input, context) =>
         SubChannelId: [],
         Type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ChannelFlowCallbackCommand = 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 || ""}` + "/channels/{ChannelArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        operation: [, "channel-flow-callback"],
+        [_o]: [, "channel-flow-callback"],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -69,24 +54,16 @@ export const se_ChannelFlowCallbackCommand = async (input, context) => {
         ChannelMessage: (_) => _json(_),
         DeleteResource: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_CreateChannelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
+    b.bp("/channels");
     let body;
     body = JSON.stringify(take(input, {
         AppInstanceArn: [],
@@ -102,44 +79,30 @@ export const se_CreateChannelCommand = async (input, context) => {
         Privacy: [],
         Tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateChannelBanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/bans");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         MemberArn: [],
     }));
-    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_CreateChannelFlowCommand = 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 || ""}` + "/channel-flows";
+    b.bp("/channel-flows");
     let body;
     body = JSON.stringify(take(input, {
         AppInstanceArn: [],
@@ -148,860 +111,546 @@ export const se_CreateChannelFlowCommand = async (input, context) => {
         Processors: (_) => _json(_),
         Tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateChannelMembershipCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/memberships";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/memberships");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         MemberArn: [],
         SubChannelId: [],
         Type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateChannelModeratorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/moderators";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/moderators");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         ChannelModeratorArn: [],
     }));
-    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 = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", 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_DeleteChannelBanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans/{MemberArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
+    b.bp("/channels/{ChannelArn}/bans/{MemberArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MemberArn", () => input.MemberArn, "{MemberArn}", 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_DeleteChannelFlowCommand = 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 || ""}` + "/channel-flows/{ChannelFlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
+    b.bp("/channel-flows/{ChannelFlowArn}");
+    b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", 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_DeleteChannelMembershipCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/memberships/{MemberArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
+    b.bp("/channels/{ChannelArn}/memberships/{MemberArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
     const query = map({
-        "sub-channel-id": [, input.SubChannelId],
+        [_sci]: [, input[_SCI]],
     });
     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_DeleteChannelMessageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/messages/{MessageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
+    b.bp("/channels/{ChannelArn}/messages/{MessageId}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MessageId", () => input.MessageId, "{MessageId}", false);
     const query = map({
-        "sub-channel-id": [, input.SubChannelId],
+        [_sci]: [, input[_SCI]],
     });
     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_DeleteChannelModeratorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/moderators/{ChannelModeratorArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", false);
+    b.bp("/channels/{ChannelArn}/moderators/{ChannelModeratorArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", 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_DeleteMessagingStreamingConfigurationsCommand = 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 || ""}` +
-        "/app-instances/{AppInstanceArn}/streaming-configurations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
+    b.bp("/app-instances/{AppInstanceArn}/streaming-configurations");
+    b.p("AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", 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_DescribeChannelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", 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_DescribeChannelBanCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans/{MemberArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
+    b.bp("/channels/{ChannelArn}/bans/{MemberArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MemberArn", () => input.MemberArn, "{MemberArn}", 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_DescribeChannelFlowCommand = 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 || ""}` + "/channel-flows/{ChannelFlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
+    b.bp("/channel-flows/{ChannelFlowArn}");
+    b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", 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_DescribeChannelMembershipCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/memberships/{MemberArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
+    b.bp("/channels/{ChannelArn}/memberships/{MemberArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
     const query = map({
-        "sub-channel-id": [, input.SubChannelId],
+        [_sci]: [, input[_SCI]],
     });
     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_DescribeChannelMembershipForAppInstanceUserCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        scope: [, "app-instance-user-membership"],
-        "app-instance-user-arn": [, __expectNonNull(input.AppInstanceUserArn, `AppInstanceUserArn`)],
+        [_s]: [, "app-instance-user-membership"],
+        [_aiua]: [, __expectNonNull(input[_AIUA], `AppInstanceUserArn`)],
     });
     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_DescribeChannelModeratedByAppInstanceUserCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        scope: [, "app-instance-user-moderated-channel"],
-        "app-instance-user-arn": [, __expectNonNull(input.AppInstanceUserArn, `AppInstanceUserArn`)],
+        [_s]: [, "app-instance-user-moderated-channel"],
+        [_aiua]: [, __expectNonNull(input[_AIUA], `AppInstanceUserArn`)],
     });
     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_DescribeChannelModeratorCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/moderators/{ChannelModeratorArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", false);
+    b.bp("/channels/{ChannelArn}/moderators/{ChannelModeratorArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", 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_DisassociateChannelFlowCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/channel-flow/{ChannelFlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
+    b.bp("/channels/{ChannelArn}/channel-flow/{ChannelFlowArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", 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_GetChannelMembershipPreferencesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/memberships/{MemberArn}/preferences";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
+    b.bp("/channels/{ChannelArn}/memberships/{MemberArn}/preferences");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MemberArn", () => input.MemberArn, "{MemberArn}", 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_GetChannelMessageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/messages/{MessageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
+    b.bp("/channels/{ChannelArn}/messages/{MessageId}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MessageId", () => input.MessageId, "{MessageId}", false);
     const query = map({
-        "sub-channel-id": [, input.SubChannelId],
+        [_sci]: [, input[_SCI]],
     });
     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_GetChannelMessageStatusCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/messages/{MessageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
+    b.bp("/channels/{ChannelArn}/messages/{MessageId}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MessageId", () => input.MessageId, "{MessageId}", false);
     const query = map({
-        scope: [, "message-status"],
-        "sub-channel-id": [, input.SubChannelId],
+        [_s]: [, "message-status"],
+        [_sci]: [, input[_SCI]],
     });
     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_GetMessagingSessionEndpointCommand = 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 || ""}` + "/endpoints/messaging-session";
+    b.bp("/endpoints/messaging-session");
     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_GetMessagingStreamingConfigurationsCommand = 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 || ""}` +
-        "/app-instances/{AppInstanceArn}/streaming-configurations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
+    b.bp("/app-instances/{AppInstanceArn}/streaming-configurations");
+    b.p("AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", 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_ListChannelBansCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/bans");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, 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_ListChannelFlowsCommand = 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 || ""}` + "/channel-flows";
+    b.bp("/channel-flows");
     const query = map({
-        "app-instance-arn": [, __expectNonNull(input.AppInstanceArn, `AppInstanceArn`)],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
+        [_aia]: [, __expectNonNull(input[_AIA], `AppInstanceArn`)],
+        [_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_ListChannelMembershipsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/memberships";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/memberships");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        type: [, input.Type],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
-        "sub-channel-id": [, input.SubChannelId],
+        [_t]: [, input[_T]],
+        [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nt]: [, input[_NT]],
+        [_sci]: [, input[_SCI]],
     });
     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_ListChannelMembershipsForAppInstanceUserCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
+    b.bp("/channels");
     const query = map({
-        scope: [, "app-instance-user-memberships"],
-        "app-instance-user-arn": [, input.AppInstanceUserArn],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
+        [_s]: [, "app-instance-user-memberships"],
+        [_aiua]: [, input[_AIUA]],
+        [_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_ListChannelMessagesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/messages";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/messages");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        "sort-order": [, input.SortOrder],
-        "not-before": [
-            () => input.NotBefore !== void 0,
-            () => (input.NotBefore.toISOString().split(".")[0] + "Z").toString(),
-        ],
-        "not-after": [
-            () => input.NotAfter !== void 0,
-            () => (input.NotAfter.toISOString().split(".")[0] + "Z").toString(),
-        ],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
-        "sub-channel-id": [, input.SubChannelId],
+        [_so]: [, input[_SO]],
+        [_nb]: [() => input.NotBefore !== void 0, () => (input[_NB].toISOString().split(".")[0] + "Z").toString()],
+        [_na]: [() => input.NotAfter !== void 0, () => (input[_NA].toISOString().split(".")[0] + "Z").toString()],
+        [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nt]: [, input[_NT]],
+        [_sci]: [, input[_SCI]],
     });
     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_ListChannelModeratorsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/moderators";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/moderators");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, 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_ListChannelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
+    b.bp("/channels");
     const query = map({
-        "app-instance-arn": [, __expectNonNull(input.AppInstanceArn, `AppInstanceArn`)],
-        privacy: [, input.Privacy],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
+        [_aia]: [, __expectNonNull(input[_AIA], `AppInstanceArn`)],
+        [_p]: [, input[_P]],
+        [_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_ListChannelsAssociatedWithChannelFlowCommand = 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 || ""}` + "/channels";
+    b.bp("/channels");
     const query = map({
-        scope: [, "channel-flow-associations"],
-        "channel-flow-arn": [, __expectNonNull(input.ChannelFlowArn, `ChannelFlowArn`)],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
+        [_s]: [, "channel-flow-associations"],
+        [_cfa]: [, __expectNonNull(input[_CFA], `ChannelFlowArn`)],
+        [_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_ListChannelsModeratedByAppInstanceUserCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
+    b.bp("/channels");
     const query = map({
-        scope: [, "app-instance-user-moderated-channels"],
-        "app-instance-user-arn": [, input.AppInstanceUserArn],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
+        [_s]: [, "app-instance-user-moderated-channels"],
+        [_aiua]: [, input[_AIUA]],
+        [_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_ListSubChannelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/subchannels";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/subchannels");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     const query = map({
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, 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 = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        arn: [, __expectNonNull(input.ResourceARN, `ResourceARN`)],
+        [_a]: [, __expectNonNull(input[_RARN], `ResourceARN`)],
     });
     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_PutChannelExpirationSettingsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/expiration-settings";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/expiration-settings");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         ExpirationSettings: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutChannelMembershipPreferencesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/memberships/{MemberArn}/preferences";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
+    b.bp("/channels/{ChannelArn}/memberships/{MemberArn}/preferences");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         Preferences: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_PutMessagingStreamingConfigurationsCommand = 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 || ""}` +
-        "/app-instances/{AppInstanceArn}/streaming-configurations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
+    b.bp("/app-instances/{AppInstanceArn}/streaming-configurations");
+    b.p("AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         StreamingConfigurations: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_RedactChannelMessageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/messages/{MessageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
+    b.bp("/channels/{ChannelArn}/messages/{MessageId}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MessageId", () => input.MessageId, "{MessageId}", false);
     const query = map({
-        operation: [, "redact"],
+        [_o]: [, "redact"],
     });
     let body;
     body = JSON.stringify(take(input, {
         SubChannelId: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_SearchChannelsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
+    b.bp("/channels");
     const query = map({
-        operation: [, "search"],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
-        "next-token": [, input.NextToken],
+        [_o]: [, "search"],
+        [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+        [_nt]: [, input[_NT]],
     });
     let body;
     body = JSON.stringify(take(input, {
         Fields: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_SendChannelMessageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/messages";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/messages");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1015,122 +664,84 @@ export const se_SendChannelMessageCommand = async (input, context) => {
         Target: (_) => _json(_),
         Type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_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",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        operation: [, "tag-resource"],
+        [_o]: [, "tag-resource"],
     });
     let body;
     body = JSON.stringify(take(input, {
         ResourceARN: [],
         Tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_UntagResourceCommand = 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 || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        operation: [, "untag-resource"],
+        [_o]: [, "untag-resource"],
     });
     let body;
     body = JSON.stringify(take(input, {
         ResourceARN: [],
         TagKeys: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_UpdateChannelCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         Metadata: [],
         Mode: [],
         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_UpdateChannelFlowCommand = 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 || ""}` + "/channel-flows/{ChannelFlowArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
+    b.bp("/channel-flows/{ChannelFlowArn}");
+    b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         Name: [],
         Processors: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateChannelMessageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/channels/{ChannelArn}/messages/{MessageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
+    b.bp("/channels/{ChannelArn}/messages/{MessageId}");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.p("MessageId", () => input.MessageId, "{MessageId}", false);
     let body;
     body = JSON.stringify(take(input, {
         Content: [],
@@ -1138,33 +749,19 @@ export const se_UpdateChannelMessageCommand = async (input, context) => {
         Metadata: [],
         SubChannelId: [],
     }));
-    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_UpdateChannelReadMarkerCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-chime-bearer": input.ChimeBearer,
+        [_xacb]: input[_CB],
     });
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/readMarker";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
+    b.bp("/channels/{ChannelArn}/readMarker");
+    b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
     let body;
-    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_AssociateChannelFlowCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4002,6 +3599,34 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _AIA = "AppInstanceArn";
+const _AIUA = "AppInstanceUserArn";
+const _CB = "ChimeBearer";
+const _CFA = "ChannelFlowArn";
+const _MR = "MaxResults";
+const _NA = "NotAfter";
+const _NB = "NotBefore";
+const _NT = "NextToken";
+const _P = "Privacy";
+const _RARN = "ResourceARN";
+const _SCI = "SubChannelId";
+const _SO = "SortOrder";
+const _T = "Type";
+const _a = "arn";
+const _aia = "app-instance-arn";
+const _aiua = "app-instance-user-arn";
+const _cfa = "channel-flow-arn";
+const _mr = "max-results";
+const _na = "not-after";
+const _nb = "not-before";
+const _nt = "next-token";
+const _o = "operation";
+const _p = "privacy";
+const _s = "scope";
+const _sci = "sub-channel-id";
+const _so = "sort-order";
+const _t = "type";
+const _xacb = "x-amz-chime-bearer";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);