@wildix/xbees-conversations-client 1.0.30 → 1.0.31

package/dist-es/protocols/Aws_restJson1.js

@@ -1,19 +1,18 @@
 import { ConversationsServiceException as __BaseException } from "../models/ConversationsServiceException";
-import { ChannelNotFoundException, ConversationsServiceException, ForbiddenException, MemberNotFoundException, MessageNotFoundException, ValidationException, } from "../models/models_0";
+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, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, resolvedPath as __resolvedPath, _json, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
-export const se_CreateChannelCommand = async (input, context) => {
+export const se_AddChannelMemberCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         'content-type': 'application/json',
     };
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/channels";
-    const query = map({
-        "user": [, input.userId],
-    });
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/channels/{channelId}/members";
+    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
     let body;
     body = JSON.stringify(take(input, {
-        'channel': _ => _json(_),
+        'memberId': [],
+        'memberToInvite': _ => _json(_),
     }));
     return new __HttpRequest({
         protocol,
@@ -22,23 +21,51 @@ export const se_CreateChannelCommand = async (input, context) => {
         method: "POST",
         headers,
         path: resolvedPath,
-        query,
         body,
     });
 };
-export const se_CreateMessageCommand = async (input, context) => {
+export const se_AddChannelMembersCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         'content-type': 'application/json',
     };
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/channels/{channelId}/messages";
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/channels/{channelId}/members";
     resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    let body;
+    body = JSON.stringify(take(input, {
+        'members': _ => _json(_),
+        'membersToInvite': _ => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_CreateGroupChannelCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        'content-type': 'application/json',
+    };
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/group";
     const query = map({
         "user": [, input.userId],
     });
     let body;
     body = JSON.stringify(take(input, {
-        'message': _ => se_MessageCreateFields(_, context),
+        'access': [],
+        'broadcast': [],
+        'channelId': [],
+        'description': [],
+        'members': _ => _json(_),
+        'membersToInvite': _ => _json(_),
+        'picture': [],
+        'pictureColor': [],
+        'subject': [],
     }));
     return new __HttpRequest({
         protocol,
@@ -67,6 +94,27 @@ export const se_DeleteChannelCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteChannelMemberCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "silent": [() => input.silent !== void 0, () => (input.silent.toString())],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_DeleteMessageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -84,6 +132,28 @@ export const se_DeleteMessageCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteMessageReactionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_GetChannelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -117,6 +187,31 @@ export const se_GetChannelMemberCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetDirectChannelIdCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        'content-type': 'application/json',
+    };
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/direct/get_channel_id";
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'participantId': [],
+        'participantToInvite': _ => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_GetMessageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -134,15 +229,112 @@ export const se_GetMessageCommand = async (input, context) => {
         body,
     });
 };
-export const se_JoinChannelCommand = async (input, context) => {
+export const se_GetMessageReactionsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     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);
+    const query = map({
+        "limit": [() => input.limit !== void 0, () => (input.limit.toString())],
+        "offset": [() => input.offset !== void 0, () => (input.offset.toString())],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_GetOrCreateDirectChannelCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        'content-type': 'application/json',
+    };
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/direct/get_or_create_channel";
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'memberId': [],
+        'memberToInvite': _ => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_InviteCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        'content-type': 'application/json',
+    };
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/invite";
+    let body;
+    body = JSON.stringify(take(input, {
+        'invitees': _ => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_JoinChannelCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
     const query = map({
         "user": [, input.userId],
     });
     let body;
+    body = JSON.stringify(take(input, {
+        'silent': [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_LeaveChannelCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'silent': [],
+    }));
     return new __HttpRequest({
         protocol,
         hostname,
@@ -154,6 +346,27 @@ export const se_JoinChannelCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListChannelMembersCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "limit": [() => input.limit !== void 0, () => (input.limit.toString())],
+        "offset": [() => input.offset !== void 0, () => (input.offset.toString())],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListChannelsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -191,6 +404,26 @@ export const se_ListMessagesCommand = async (input, context) => {
         body,
     });
 };
+export const se_MarkReadCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_PartialUpdateChannelCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -225,12 +458,9 @@ export const se_PartialUpdateMessageCommand = async (input, context) => {
     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);
-    const query = map({
-        "user": [, input.userId],
-    });
     let body;
     body = JSON.stringify(take(input, {
-        'set': _ => se_MessageUpdateFields(_, context),
+        'set': _ => se_PartialUpdateMessageSetInput(_, context),
         'unset': _ => _json(_),
     }));
     return new __HttpRequest({
@@ -240,7 +470,6 @@ export const se_PartialUpdateMessageCommand = async (input, context) => {
         method: "PATCH",
         headers,
         path: resolvedPath,
-        query,
         body,
     });
 };
@@ -264,78 +493,850 @@ export const se_ScheduleExternalFlagAdjustmentJobCommand = async (input, context
         body,
     });
 };
-export const se_UpdateChannelCommand = async (input, context) => {
+export const se_SendGiphyCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         'content-type': 'application/json',
     };
-    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/channels/{channelId}";
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/channels/{channelId}/send_giphy";
     resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
     const query = map({
         "user": [, input.userId],
     });
     let body;
     body = JSON.stringify(take(input, {
-        'channel': _ => _json(_),
+        'giphy': _ => _json(_),
+        'messageId': [],
     }));
     return new __HttpRequest({
         protocol,
         hostname,
         port,
-        method: "PUT",
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_SendMessageCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'attachments': _ => _json(_),
+        'forward': _ => _json(_),
+        'mentions': _ => _json(_),
+        'messageId': [],
+        'quote': _ => se_Message(_, context),
+        'text': [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
         headers,
         path: resolvedPath,
         query,
         body,
     });
 };
-export const se_UpdateMessageCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = {
-        'content-type': 'application/json',
+export const se_SendMessageReactionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'reactionType': [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_SendSystemMessageCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        'content-type': 'application/json',
+    };
+    let resolvedPath = `${basePath?.endsWith('/') ? basePath.slice(0, -1) : (basePath || '')}` + "/v2/conversations/channels/{channelId}/send_system_message";
+    resolvedPath = __resolvedPath(resolvedPath, input, 'channelId', () => input.channelId, '{channelId}', false);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'messageId': [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_SendTypingStartCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_SendTypingStopCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_UpdateChannelCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    const query = map({
+        "user": [, input.userId],
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'access': [],
+        'broadcast': [],
+        'description': [],
+        'picture': [],
+        'pictureColor': [],
+        'subject': [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const se_UpdateMessageCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    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);
+    let body;
+    body = JSON.stringify(take(input, {
+        'attachments': _ => _json(_),
+        'forward': _ => _json(_),
+        'mentions': _ => _json(_),
+        'quote': _ => se_Message(_, context),
+        'text': [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const de_AddChannelMemberCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_AddChannelMemberCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'member': _json,
+        'user': _json,
+    });
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'members': _json,
+        'users': _json,
+    });
+    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);
+    }
+    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);
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    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);
+    }
+    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);
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'member': _json,
+        'user': _json,
+    });
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'channelId': __expectString,
+    });
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'message': _ => de_Message(_, 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_GetMessageReactionsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetMessageReactionsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'reactions': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetMessageReactionsCommandError = 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);
+    }
+    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);
+    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_InviteCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_InviteCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'users': _json,
+    });
+    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);
+    }
+    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);
+    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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_LeaveChannelCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context)
     };
-    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);
-    const query = map({
-        "user": [, input.userId],
-    });
-    let body;
-    body = JSON.stringify(take(input, {
-        'message': _ => se_MessageUpdateFields(_, context),
-    }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    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_CreateChannelCommand = async (output, context) => {
+export const de_ListChannelMembersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateChannelCommandError(output, context);
+        return de_ListChannelMembersCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'channel': _json,
+        'members': _json,
+        'users': _json,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateChannelCommandError = async (output, context) => {
+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);
@@ -351,30 +1352,30 @@ const de_CreateChannelCommandError = async (output, context) => {
             });
     }
 };
-export const de_CreateMessageCommand = async (output, context) => {
+export const de_ListChannelsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CreateMessageCommandError(output, context);
+        return de_ListChannelsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'message': _ => de_Message(_, context),
+        'channels': _json,
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_CreateMessageCommandError = async (output, context) => {
+const de_ListChannelsCommandError = 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);
@@ -387,17 +1388,21 @@ const de_CreateMessageCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteChannelCommand = async (output, context) => {
+export const de_ListMessagesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteChannelCommandError(output, context);
+        return de_ListMessagesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    await collectBody(output.body, context);
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'messages': _ => de_MessagesList(_, context),
+    });
+    Object.assign(contents, doc);
     return contents;
 };
-const de_DeleteChannelCommandError = async (output, context) => {
+const de_ListMessagesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -407,6 +1412,9 @@ const de_DeleteChannelCommandError = async (output, context) => {
         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);
@@ -419,9 +1427,9 @@ const de_DeleteChannelCommandError = async (output, context) => {
             });
     }
 };
-export const de_DeleteMessageCommand = async (output, context) => {
+export const de_MarkReadCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_DeleteMessageCommandError(output, context);
+        return de_MarkReadCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -429,7 +1437,7 @@ export const de_DeleteMessageCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_DeleteMessageCommandError = async (output, context) => {
+const de_MarkReadCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -439,9 +1447,9 @@ const de_DeleteMessageCommandError = async (output, context) => {
         case "ChannelNotFoundException":
         case "wildix.xbees.conversations#ChannelNotFoundException":
             throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "MessageNotFoundException":
-        case "wildix.xbees.conversations#MessageNotFoundException":
-            throw await de_MessageNotFoundExceptionRes(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);
@@ -454,9 +1462,9 @@ const de_DeleteMessageCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetChannelCommand = async (output, context) => {
+export const de_PartialUpdateChannelCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetChannelCommandError(output, context);
+        return de_PartialUpdateChannelCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -468,7 +1476,7 @@ export const de_GetChannelCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetChannelCommandError = async (output, context) => {
+const de_PartialUpdateChannelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -478,6 +1486,9 @@ const de_GetChannelCommandError = async (output, context) => {
         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);
@@ -490,21 +1501,21 @@ const de_GetChannelCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetChannelMemberCommand = async (output, context) => {
+export const de_PartialUpdateMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetChannelMemberCommandError(output, context);
+        return de_PartialUpdateMessageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'member': _json,
+        'message': _ => de_Message(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_GetChannelMemberCommandError = async (output, context) => {
+const de_PartialUpdateMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -514,9 +1525,12 @@ const de_GetChannelMemberCommandError = async (output, context) => {
         case "ChannelNotFoundException":
         case "wildix.xbees.conversations#ChannelNotFoundException":
             throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "MemberNotFoundException":
-        case "wildix.xbees.conversations#MemberNotFoundException":
-            throw await de_MemberNotFoundExceptionRes(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);
@@ -529,30 +1543,29 @@ const de_GetChannelMemberCommandError = async (output, context) => {
             });
     }
 };
-export const de_GetMessageCommand = async (output, context) => {
+export const de_ScheduleExternalFlagAdjustmentJobCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetMessageCommandError(output, context);
+        return de_ScheduleExternalFlagAdjustmentJobCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
-    const doc = take(data, {
-        'message': _ => de_Message(_, context),
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_GetMessageCommandError = async (output, context) => {
+const de_ScheduleExternalFlagAdjustmentJobCommandError = 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 "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);
@@ -565,21 +1578,21 @@ const de_GetMessageCommandError = async (output, context) => {
             });
     }
 };
-export const de_JoinChannelCommand = async (output, context) => {
+export const de_SendGiphyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_JoinChannelCommandError(output, context);
+        return de_SendGiphyCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'channel': _json,
+        'message': _ => de_Message(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_JoinChannelCommandError = async (output, context) => {
+const de_SendGiphyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -604,27 +1617,33 @@ const de_JoinChannelCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListChannelsCommand = async (output, context) => {
+export const de_SendMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListChannelsCommandError(output, context);
+        return de_SendMessageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'channels': _json,
+        'message': _ => de_Message(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_ListChannelsCommandError = async (output, context) => {
+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);
@@ -637,21 +1656,17 @@ const de_ListChannelsCommandError = async (output, context) => {
             });
     }
 };
-export const de_ListMessagesCommand = async (output, context) => {
+export const de_SendMessageReactionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ListMessagesCommandError(output, context);
+        return de_SendMessageReactionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
-    const doc = take(data, {
-        'messages': _ => de_MessagesList(_, context),
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_ListMessagesCommandError = async (output, context) => {
+const de_SendMessageReactionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -661,6 +1676,9 @@ const de_ListMessagesCommandError = async (output, context) => {
         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);
@@ -673,21 +1691,21 @@ const de_ListMessagesCommandError = async (output, context) => {
             });
     }
 };
-export const de_PartialUpdateChannelCommand = async (output, context) => {
+export const de_SendSystemMessageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_PartialUpdateChannelCommandError(output, context);
+        return de_SendSystemMessageCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'channel': _json,
+        'message': _ => de_Message(_, context),
     });
     Object.assign(contents, doc);
     return contents;
 };
-const de_PartialUpdateChannelCommandError = async (output, context) => {
+const de_SendSystemMessageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -697,6 +1715,9 @@ const de_PartialUpdateChannelCommandError = async (output, context) => {
         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);
@@ -709,21 +1730,17 @@ const de_PartialUpdateChannelCommandError = async (output, context) => {
             });
     }
 };
-export const de_PartialUpdateMessageCommand = async (output, context) => {
+export const de_SendTypingStartCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_PartialUpdateMessageCommandError(output, context);
+        return de_SendTypingStartCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
-    const doc = take(data, {
-        'message': _ => de_Message(_, context),
-    });
-    Object.assign(contents, doc);
+    await collectBody(output.body, context);
     return contents;
 };
-const de_PartialUpdateMessageCommandError = async (output, context) => {
+const de_SendTypingStartCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context)
@@ -733,9 +1750,9 @@ const de_PartialUpdateMessageCommandError = async (output, context) => {
         case "ChannelNotFoundException":
         case "wildix.xbees.conversations#ChannelNotFoundException":
             throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
-        case "MessageNotFoundException":
-        case "wildix.xbees.conversations#MessageNotFoundException":
-            throw await de_MessageNotFoundExceptionRes(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);
@@ -748,9 +1765,9 @@ const de_PartialUpdateMessageCommandError = async (output, context) => {
             });
     }
 };
-export const de_ScheduleExternalFlagAdjustmentJobCommand = async (output, context) => {
+export const de_SendTypingStopCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_ScheduleExternalFlagAdjustmentJobCommandError(output, context);
+        return de_SendTypingStopCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -758,16 +1775,16 @@ export const de_ScheduleExternalFlagAdjustmentJobCommand = async (output, contex
     await collectBody(output.body, context);
     return contents;
 };
-const de_ScheduleExternalFlagAdjustmentJobCommandError = async (output, context) => {
+const de_SendTypingStopCommandError = 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 "ChannelNotFoundException":
+        case "wildix.xbees.conversations#ChannelNotFoundException":
+            throw await de_ChannelNotFoundExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "smithy.framework#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
@@ -807,6 +1824,9 @@ const de_UpdateChannelCommandError = async (output, context) => {
         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);
@@ -843,6 +1863,9 @@ const de_UpdateMessageCommandError = async (output, context) => {
         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);
@@ -885,6 +1908,19 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ChannelAlreadyExistExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ChannelAlreadyExistException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ChannelNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -911,6 +1947,19 @@ const de_ConversationsServiceExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_MemberAlreadyExistExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MemberAlreadyExistException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_MemberNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -960,35 +2009,12 @@ const se_Message = (input, context) => {
         'user': _json,
     });
 };
-const se_MessageCreateFields = (input, context) => {
-    return take(input, {
-        'attachments': _json,
-        'event': [],
-        'forward': _json,
-        'giphy': _json,
-        'mentions': _json,
-        'messageId': [],
-        'quote': _ => se_Message(_, context),
-        'silent': [],
-        'sms': [],
-        'smsStatus': [],
-        'text': [],
-        'type': [],
-    });
-};
-const se_MessageUpdateFields = (input, context) => {
+const se_PartialUpdateMessageSetInput = (input, context) => {
     return take(input, {
         'attachments': _json,
-        'event': [],
         'forward': _json,
-        'giphy': _json,
-        'mentions': _json,
         'quote': _ => se_Message(_, context),
-        'silent': [],
-        'sms': [],
-        'smsStatus': [],
         'text': [],
-        'type': [],
     });
 };
 const de_Message = (output, context) => {