@wildix/xbees-conversations-client 1.0.34 → 1.0.36

package/dist-es/protocols/Aws_restJson1.js

@@ -1,61 +1,51 @@
 import { ConversationsServiceException as __BaseException } from "../models/ConversationsServiceException";
 import { ChannelAlreadyExistException, ChannelNotFoundException, ConversationsServiceException, ForbiddenException, MemberAlreadyExistException, MemberNotFoundException, MessageNotFoundException, ValidationException, } from "../models/models_0";
-import { HttpRequest as __HttpRequest, } from "@smithy/protocol-http";
-import { decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, resolvedPath as __resolvedPath, _json, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
+import { requestBuilder as rb } from "@smithy/core";
+import { decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, _json, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
 export const se_AddChannelMemberCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/members";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/members");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     let body;
     body = JSON.stringify(take(input, {
         'memberId': [],
         'memberToInvite': _ => _json(_),
         'silent': [],
     }));
-    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_AddChannelMembersCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/members";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/members");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     let body;
     body = JSON.stringify(take(input, {
         'members': _ => _json(_),
         'membersToInvite': _ => _json(_),
         'silent': [],
     }));
-    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_CreateGroupChannelCommand = 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 || '')}` + "/v2/conversations/group";
+    b.bp("/v2/conversations/group");
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -69,496 +59,382 @@ export const se_CreateGroupChannelCommand = async (input, context) => {
         'pictureColor': [],
         'subject': [],
     }));
-    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_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 || '')}` + "/v2/conversations/channels/{channelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/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_DeleteChannelMemberCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/members/{memberId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'memberId', () => input.memberId, '{memberId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/members/{memberId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('memberId', () => input.memberId, '{memberId}', false);
     const query = map({
-        "silent": [() => input.silent !== void 0, () => (input.silent.toString())],
+        [_s]: [() => input.silent !== void 0, () => (input[_s].toString())],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("DELETE")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_DeleteMessageCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages/{messageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'messageId', () => input.messageId, '{messageId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages/{messageId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('messageId', () => input.messageId, '{messageId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     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_DeleteMessageReactionCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages/{messageId}/reactions/{reactionType}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'messageId', () => input.messageId, '{messageId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'reactionType', () => input.reactionType, '{reactionType}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages/{messageId}/reactions/{reactionType}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('messageId', () => input.messageId, '{messageId}', false);
+    b.p('reactionType', () => input.reactionType, '{reactionType}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     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_GetChannelCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/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_GetChannelMemberCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/members/{memberId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'memberId', () => input.memberId, '{memberId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/members/{memberId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('memberId', () => input.memberId, '{memberId}', 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_GetDirectChannelIdCommand = 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 || '')}` + "/v2/conversations/direct/get_channel_id";
+    b.bp("/v2/conversations/direct/get_channel_id");
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
-        'participantId': [],
-        'participantToInvite': _ => _json(_),
+        'memberId': [],
+        'memberToInvite': _ => _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_GetMessageCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages/{messageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'messageId', () => input.messageId, '{messageId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages/{messageId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('messageId', () => input.messageId, '{messageId}', 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_GetOrCreateDirectChannelCommand = 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 || '')}` + "/v2/conversations/direct/get_or_create_channel";
+    b.bp("/v2/conversations/direct/get_or_create_channel");
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
         'memberId': [],
         'memberToInvite': _ => _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_HideChannelCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/hide";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/hide");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_InviteCommand = 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 || '')}` + "/v2/conversations/invite";
+    b.bp("/v2/conversations/invite");
     let body;
     body = JSON.stringify(take(input, {
         'invitees': _ => _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_JoinChannelCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/join";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/join");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
         'silent': [],
     }));
-    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_LeaveChannelCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/leave";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/leave");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
         'silent': [],
     }));
-    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_ListChannelMembersCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/members";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/members");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "limit": [() => input.limit !== void 0, () => (input.limit.toString())],
-        "offset": [() => input.offset !== void 0, () => (input.offset.toString())],
+        [_l]: [() => input.limit !== void 0, () => (input[_l].toString())],
+        [_o]: [() => input.offset !== void 0, () => (input[_o].toString())],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_ListChannelsCommand = 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 || '')}` + "/v2/conversations/channels";
+    b.bp("/v2/conversations/channels");
     const query = map({
-        "user": [, input.userId],
-        "limit": [() => input.limit !== void 0, () => (input.limit.toString())],
-        "offset": [() => input.offset !== void 0, () => (input.offset.toString())],
+        [_u]: [, input[_uI]],
+        [_l]: [() => input.limit !== void 0, () => (input[_l].toString())],
+        [_o]: [() => input.offset !== void 0, () => (input[_o].toString())],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_ListMessageReactionsCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages/{messageId}/reactions";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'messageId', () => input.messageId, '{messageId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages/{messageId}/reactions");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('messageId', () => input.messageId, '{messageId}', false);
     const query = map({
-        "limit": [() => input.limit !== void 0, () => (input.limit.toString())],
-        "offset": [() => input.offset !== void 0, () => (input.offset.toString())],
+        [_l]: [() => input.limit !== void 0, () => (input[_l].toString())],
+        [_o]: [() => input.offset !== void 0, () => (input[_o].toString())],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_ListMessagesCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "limit": [() => input.limit !== void 0, () => (input.limit.toString())],
-        "offset": [() => input.offset !== void 0, () => (input.offset.toString())],
+        [_l]: [() => input.limit !== void 0, () => (input[_l].toString())],
+        [_o]: [() => input.offset !== void 0, () => (input[_o].toString())],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_MarkReadCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/read";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/read");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_PartialUpdateChannelCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
         'set': _ => _json(_),
+        'silent': [],
         'unset': _ => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("PATCH")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_PartialUpdateMessageCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages/{messageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'messageId', () => input.messageId, '{messageId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages/{messageId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('messageId', () => input.messageId, '{messageId}', false);
     let body;
     body = JSON.stringify(take(input, {
         'set': _ => _json(_),
         'unset': _ => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PATCH",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PATCH")
+        .h(headers)
+        .b(body);
+    return b.build();
 };
 export const se_ScheduleExternalFlagAdjustmentJobCommand = 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 || '')}` + "/v2/conversations/schedule_external_flag_adjustment_job";
+    b.bp("/v2/conversations/schedule_external_flag_adjustment_job");
     let body;
     body = JSON.stringify(take(input, {
         'userId': [],
     }));
-    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_SendGiphyCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/send_giphy";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/send_giphy");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
         'giphy': _ => _json(_),
         'messageId': [],
     }));
-    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_SendMessageCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -569,112 +445,87 @@ export const se_SendMessageCommand = async (input, context) => {
         'quote': _ => _json(_),
         'text': [],
     }));
-    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_SendMessageReactionCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages/{messageId}/reactions";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'messageId', () => input.messageId, '{messageId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages/{messageId}/reactions");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('messageId', () => input.messageId, '{messageId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
         'reactionType': [],
     }));
-    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_SendTypingStartCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/send_typing_start";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/send_typing_start");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_SendTypingStopCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/send_typing_stop";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/send_typing_stop");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_ShowChannelCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/show";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/show");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_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 || '')}` + "/v2/conversations/channels/{channelId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    b.bp("/v2/conversations/channels/{channelId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
     const query = map({
-        "user": [, input.userId],
+        [_u]: [, input[_uI]],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -683,27 +534,23 @@ export const se_UpdateChannelCommand = async (input, context) => {
         'description': [],
         'picture': [],
         'pictureColor': [],
+        'silent': [],
         'subject': [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("PUT")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
 };
 export const se_UpdateMessageCommand = 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 || '')}` + "/v2/conversations/channels/{channelId}/messages/{messageId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
-    resolvedPath = __resolvedPath(resolvedPath, input, 'messageId', () => input.messageId, '{messageId}', false);
+    b.bp("/v2/conversations/channels/{channelId}/messages/{messageId}");
+    b.p('channelId', () => input.channelId, '{channelId}', false);
+    b.p('messageId', () => input.messageId, '{messageId}', false);
     let body;
     body = JSON.stringify(take(input, {
         'attachments': _ => _json(_),
@@ -712,19 +559,14 @@ export const se_UpdateMessageCommand = async (input, context) => {
         'quote': _ => _json(_),
         'text': [],
     }));
-    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_AddChannelMemberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_AddChannelMemberCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -737,37 +579,9 @@ export const de_AddChannelMemberCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_AddChannelMemberCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MemberAlreadyExistException":
-        case "wildix.xbees.conversations#MemberAlreadyExistException":
-            throw await de_MemberAlreadyExistExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_AddChannelMembersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_AddChannelMembersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -780,37 +594,9 @@ export const de_AddChannelMembersCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_AddChannelMembersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MemberAlreadyExistException":
-        case "wildix.xbees.conversations#MemberAlreadyExistException":
-            throw await de_MemberAlreadyExistExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_CreateGroupChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateGroupChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -822,34 +608,9 @@ export const de_CreateGroupChannelCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateGroupChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelAlreadyExistException":
-        case "wildix.xbees.conversations#ChannelAlreadyExistException":
-            throw await de_ChannelAlreadyExistExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_DeleteChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -857,34 +618,9 @@ export const de_DeleteChannelCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_DeleteChannelMemberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteChannelMemberCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -892,37 +628,9 @@ export const de_DeleteChannelMemberCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteChannelMemberCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MemberNotFoundException":
-        case "wildix.xbees.conversations#MemberNotFoundException":
-            throw await de_MemberNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_DeleteMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteMessageCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -930,37 +638,9 @@ export const de_DeleteMessageCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteMessageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MessageNotFoundException":
-        case "wildix.xbees.conversations#MessageNotFoundException":
-            throw await de_MessageNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_DeleteMessageReactionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteMessageReactionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -968,37 +648,9 @@ export const de_DeleteMessageReactionCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteMessageReactionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MessageNotFoundException":
-        case "wildix.xbees.conversations#MessageNotFoundException":
-            throw await de_MessageNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_GetChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1010,34 +662,9 @@ export const de_GetChannelCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_GetChannelMemberCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetChannelMemberCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1050,37 +677,9 @@ export const de_GetChannelMemberCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetChannelMemberCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MemberNotFoundException":
-        case "wildix.xbees.conversations#MemberNotFoundException":
-            throw await de_MemberNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_GetDirectChannelIdCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetDirectChannelIdCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1092,31 +691,9 @@ export const de_GetDirectChannelIdCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetDirectChannelIdCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_GetMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetMessageCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1128,34 +705,9 @@ export const de_GetMessageCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetMessageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_GetOrCreateDirectChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetOrCreateDirectChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1167,70 +719,19 @@ export const de_GetOrCreateDirectChannelCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetOrCreateDirectChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_HideChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_HideChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
-    const doc = take(data, {
-        'channel': _json,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_HideChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_InviteCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_InviteCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1242,31 +743,9 @@ export const de_InviteCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_InviteCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_JoinChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_JoinChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1278,34 +757,9 @@ export const de_JoinChannelCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_JoinChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_LeaveChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_LeaveChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1313,34 +767,9 @@ export const de_LeaveChannelCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_LeaveChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_ListChannelMembersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListChannelMembersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1353,34 +782,9 @@ export const de_ListChannelMembersCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListChannelMembersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_ListChannelsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListChannelsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1392,31 +796,9 @@ export const de_ListChannelsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListChannelsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_ListMessageReactionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListMessageReactionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1428,34 +810,9 @@ export const de_ListMessageReactionsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListMessageReactionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_ListMessagesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListMessagesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1467,34 +824,9 @@ export const de_ListMessagesCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListMessagesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_MarkReadCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_MarkReadCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1502,34 +834,9 @@ export const de_MarkReadCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_MarkReadCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_PartialUpdateChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_PartialUpdateChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1541,34 +848,9 @@ export const de_PartialUpdateChannelCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_PartialUpdateChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_PartialUpdateMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_PartialUpdateMessageCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1580,37 +862,9 @@ export const de_PartialUpdateMessageCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_PartialUpdateMessageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MessageNotFoundException":
-        case "wildix.xbees.conversations#MessageNotFoundException":
-            throw await de_MessageNotFoundExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_ScheduleExternalFlagAdjustmentJobCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ScheduleExternalFlagAdjustmentJobCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1618,34 +872,9 @@ export const de_ScheduleExternalFlagAdjustmentJobCommand = async (output, contex
     await collectBody(output.body, context);
     return contents;
 };
-const de_ScheduleExternalFlagAdjustmentJobCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConversationsServiceException":
-        case "wildix.xbees.conversations#ConversationsServiceException":
-            throw await de_ConversationsServiceExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_SendGiphyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SendGiphyCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1657,34 +886,9 @@ export const de_SendGiphyCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_SendGiphyCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_SendMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SendMessageCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1696,34 +900,9 @@ export const de_SendMessageCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_SendMessageCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_SendMessageReactionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SendMessageReactionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1731,34 +910,9 @@ export const de_SendMessageReactionCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_SendMessageReactionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_SendTypingStartCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SendTypingStartCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1766,34 +920,9 @@ export const de_SendTypingStartCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_SendTypingStartCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_SendTypingStopCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_SendTypingStopCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1801,73 +930,19 @@ export const de_SendTypingStopCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_SendTypingStopCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_ShowChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ShowChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
-    const doc = take(data, {
-        'channel': _json,
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_ShowChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_UpdateChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateChannelCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1879,34 +954,9 @@ export const de_UpdateChannelCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateChannelCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context)
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ChannelNotFoundException":
-        case "wildix.xbees.conversations#ChannelNotFoundException":
-            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "ForbiddenException":
-        case "smithy.framework#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "ValidationException":
-        case "smithy.framework#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode
-            });
-    }
-};
 export const de_UpdateMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_UpdateMessageCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -1918,7 +968,7 @@ export const de_UpdateMessageCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_UpdateMessageCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -1931,12 +981,24 @@ const de_UpdateMessageCommandError = async (output, context) => {
         case "ForbiddenException":
         case "smithy.framework#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
-        case "MessageNotFoundException":
-        case "wildix.xbees.conversations#MessageNotFoundException":
-            throw await de_MessageNotFoundExceptionRes(parsedOutput, context);
+        case "MemberAlreadyExistException":
+        case "wildix.xbees.conversations#MemberAlreadyExistException":
+            throw await de_MemberAlreadyExistExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "smithy.framework#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ChannelAlreadyExistException":
+        case "wildix.xbees.conversations#ChannelAlreadyExistException":
+            throw await de_ChannelAlreadyExistExceptionRes(parsedOutput, context);
+        case "MemberNotFoundException":
+        case "wildix.xbees.conversations#MemberNotFoundException":
+            throw await de_MemberNotFoundExceptionRes(parsedOutput, context);
+        case "MessageNotFoundException":
+        case "wildix.xbees.conversations#MessageNotFoundException":
+            throw await de_MessageNotFoundExceptionRes(parsedOutput, context);
+        case "ConversationsServiceException":
+        case "wildix.xbees.conversations#ConversationsServiceException":
+            throw await de_ConversationsServiceExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -2064,6 +1126,11 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     (!Object.getOwnPropertyNames(value).includes("length") ||
         value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _l = "limit";
+const _o = "offset";
+const _s = "silent";
+const _u = "user";
+const _uI = "userId";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then(encoded => {
     if (encoded.length) {
         return JSON.parse(encoded);