@sendbird/sendbird-platform-sdk-typescript 2.0.0

package/dist/tests/integration/groupChannel.test.js

@@ -0,0 +1,1238 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SendbirdBasicUserInfo, SendbirdDisappearingMessage, SendbirdMessageResponse, SendbirdSmsFallback, SendbirdUser, SendbirdGroupChannelDetailChannel, } from "../../models/ObjectSerializer";
+import { hasValidField } from "./helper";
+import { ServerConfiguration } from "../../servers";
+import { createConfiguration } from "../../configuration";
+import { GroupChannelApi } from "../../index";
+import { GLOBAL_GROUP_CHANNEL_ACCESS_CODE, MASTER_USER_ID, SECOND_USER_ID, USERS, } from "./constants";
+describe("Group Channel API", () => {
+    const APP_ID = process.env.APP_ID || "";
+    const API_TOKEN = process.env.API_TOKEN || "";
+    let groupChannelApi;
+    const validSendbirdGroupChannelCountPreferenceEnum = [
+        "false",
+        "all",
+        "unread_message_count_only",
+        "unread_mentioned_count_only",
+    ];
+    const validSendbirdGroupChannelMemberStateEnum = ["invited", "joined", "none"];
+    const validSendbirdGroupChannelHiddenStateEnum = ["hidden_allow_auto_unhide", "hidden_prevent_auto_unhide", "unhidden"];
+    const validSendbirdGroupChannelMyRoleEnum = ["none", "operator", ""];
+    const validSendbirdMemberRoleEnum = [
+        "",
+        "none",
+        "operator",
+    ];
+    const validSendbirdMemberStateEnum = ["", "invited", "joined"];
+    beforeEach(() => {
+        const serverConfig = new ServerConfiguration(`https://api-${APP_ID}.sendbird.com`, { app_id: APP_ID });
+        const configuration = createConfiguration({
+            baseServer: serverConfig,
+        });
+        groupChannelApi = new GroupChannelApi(configuration);
+    });
+    it("call listChannels with positive query params", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const CHANNEL_URL = "create-group-channel-before-call-list-channels-with-positive-params-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        expect(createGroupChannelresponse).toBeDefined();
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        const response = yield groupChannelApi.listChannels({
+            apiToken: API_TOKEN,
+            limit: 10,
+            distinctMode: "all",
+            publicMode: "all",
+            superMode: "all",
+            showEmpty: true,
+            showMember: true,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMetadata: true,
+            showFrozen: true,
+        });
+        expect(response).toHaveProperty("channels");
+        expect(Array.isArray(response.channels)).toBe(true);
+        (_a = response.channels) === null || _a === void 0 ? void 0 : _a.forEach((channel) => {
+            expect(channel).toHaveProperty("channelUrl");
+            expect(typeof channel.channelUrl).toBe("string");
+            if ("countPreference" in channel) {
+                expect(typeof channel.countPreference).toBe("string");
+                expect(validSendbirdGroupChannelCountPreferenceEnum.includes(channel.countPreference)).toBe(true);
+            }
+            expect(channel).toHaveProperty("name");
+            expect(typeof channel.name).toBe("string");
+            expect(channel).toHaveProperty("coverUrl");
+            expect(typeof channel.coverUrl).toBe("string");
+            expect(channel).toHaveProperty("createdAt");
+            expect(typeof channel.createdAt).toBe("number");
+            if (hasValidField(channel, "createdBy")) {
+                expect(channel.createdBy).toBeInstanceOf(SendbirdBasicUserInfo);
+            }
+            expect(channel).toHaveProperty("customType");
+            expect(typeof channel.customType).toBe("string");
+            expect(channel).toHaveProperty("data");
+            expect(typeof channel.data).toBe("string");
+            expect(channel).toHaveProperty("deliveryReceipt");
+            expect(typeof channel.deliveryReceipt).toBe("object");
+            expect(channel).toHaveProperty("disappearingMessage");
+            expect(channel.disappearingMessage).toBeInstanceOf(SendbirdDisappearingMessage);
+            expect(channel).toHaveProperty("freeze");
+            expect(typeof channel.freeze).toBe("boolean");
+            expect(channel).toHaveProperty("hasAiBot");
+            expect(typeof channel.hasAiBot).toBe("boolean");
+            expect(channel).toHaveProperty("hasBot");
+            expect(typeof channel.hasBot).toBe("boolean");
+            if ("hiddenState" in channel) {
+                expect(validSendbirdGroupChannelHiddenStateEnum.includes(channel.hiddenState)).toBe(true);
+                expect(typeof channel.hiddenState).toBe("string");
+            }
+            expect(channel).toHaveProperty("ignoreProfanityFilter");
+            expect(typeof channel.ignoreProfanityFilter).toBe("boolean");
+            expect(channel).toHaveProperty("invitedAt");
+            expect(typeof channel.invitedAt).toBe("number");
+            if (hasValidField(channel, "inviter")) {
+                expect(channel.inviter).toBeInstanceOf(SendbirdUser);
+            }
+            expect(channel).toHaveProperty("isAccessCodeRequired");
+            expect(typeof channel.isAccessCodeRequired).toBe("boolean");
+            expect(channel).toHaveProperty("isBroadcast");
+            expect(typeof channel.isBroadcast).toBe("boolean");
+            expect(channel).toHaveProperty("isDiscoverable");
+            expect(typeof channel.isDiscoverable).toBe("boolean");
+            expect(channel).toHaveProperty("isDistinct");
+            expect(typeof channel.isDistinct).toBe("boolean");
+            expect(channel).toHaveProperty("isEphemeral");
+            expect(typeof channel.isEphemeral).toBe("boolean");
+            expect(channel).toHaveProperty("isExclusive");
+            expect(typeof channel.isExclusive).toBe("boolean");
+            if ("isHidden" in channel) {
+                expect(typeof channel.isHidden).toBe("boolean");
+            }
+            if ("isMuted" in channel) {
+                expect(typeof channel.isMuted).toBe("boolean");
+            }
+            if ("isPublic" in channel) {
+                expect(typeof channel.isPublic).toBe("boolean");
+            }
+            if ("isPushEnabled" in channel) {
+                expect(typeof channel.isPushEnabled).toBe("boolean");
+            }
+            expect(channel).toHaveProperty("isSuper");
+            expect(typeof channel.isSuper).toBe("boolean");
+            expect(channel).toHaveProperty("joinedMemberCount");
+            expect(typeof channel.joinedMemberCount).toBe("number");
+            if (hasValidField(channel, "joinedTs")) {
+                expect(typeof channel.joinedTs).toBe("number");
+            }
+            if (hasValidField(channel, "lastMessage")) {
+                expect(channel.lastMessage).toBeInstanceOf(SendbirdMessageResponse);
+            }
+            expect(channel).toHaveProperty("maxLengthMessage");
+            expect(typeof channel.maxLengthMessage).toBe("number");
+            expect(channel).toHaveProperty("memberCount");
+            expect(typeof channel.memberCount).toBe("number");
+            if (hasValidField(channel, "memberState")) {
+                expect(validSendbirdGroupChannelMemberStateEnum.includes(channel.memberState)).toBe(true);
+                expect(typeof channel.memberState).toBe("string");
+            }
+            expect(channel).toHaveProperty("members");
+            expect(Array.isArray(channel.members)).toBe(true);
+            expect(channel).toHaveProperty("messageSurvivalSeconds");
+            expect(typeof channel.messageSurvivalSeconds).toBe("number");
+            expect(channel).toHaveProperty("metadata");
+            expect(typeof channel.metadata).toBe("object");
+            if (hasValidField(channel, "myRole")) {
+                expect(validSendbirdGroupChannelMyRoleEnum.includes(channel.myRole)).toBe(true);
+                expect(typeof channel.myRole).toBe("string");
+            }
+            expect(channel).toHaveProperty("name");
+            expect(typeof channel.name).toBe("string");
+            expect(channel).toHaveProperty("readReceipt");
+            expect(typeof channel.readReceipt).toBe("object");
+            expect(channel).toHaveProperty("smsFallback");
+            expect(channel.smsFallback).toBeInstanceOf(SendbirdSmsFallback);
+            if (hasValidField(channel, "tsMessageOffset")) {
+                expect(typeof channel.tsMessageOffset).toBe("number");
+            }
+            expect(channel).toHaveProperty("unreadMentionCount");
+            expect(typeof channel.unreadMentionCount).toBe("number");
+            expect(channel).toHaveProperty("unreadMessageCount");
+            expect(typeof channel.unreadMessageCount).toBe("number");
+            if (hasValidField(channel, "userLastRead")) {
+                expect(typeof channel.userLastRead).toBe("number");
+            }
+        });
+        expect(response).toHaveProperty("next");
+        expect(typeof response.next).toBe("string");
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call listChannels with negative query params", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _b;
+        const CHANNEL_URL = "create-group-channel-before-call-list-channels-with-negative-params-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        expect(createGroupChannelresponse).toBeDefined();
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        const response = yield groupChannelApi.listChannels({
+            apiToken: API_TOKEN,
+            limit: 10,
+            distinctMode: "all",
+            publicMode: "all",
+            superMode: "all",
+            showEmpty: false,
+            showMember: false,
+            showDeliveryReceipt: false,
+            showReadReceipt: false,
+            showMetadata: false,
+            showFrozen: false,
+        });
+        expect(response).toHaveProperty("channels");
+        expect(Array.isArray(response.channels)).toBe(true);
+        (_b = response.channels) === null || _b === void 0 ? void 0 : _b.forEach((channel) => {
+            expect(channel).toHaveProperty("channelUrl");
+            expect(typeof channel.channelUrl).toBe("string");
+            expect(channel).not.toHaveProperty("deliveryReceipt");
+            expect(channel).not.toHaveProperty("members");
+            expect(channel).not.toHaveProperty("metadata");
+            expect(channel).not.toHaveProperty("readReceipt");
+            expect(channel).toHaveProperty("name");
+            expect(typeof channel.name).toBe("string");
+            expect(channel).toHaveProperty("coverUrl");
+            expect(typeof channel.coverUrl).toBe("string");
+            expect(channel).toHaveProperty("createdAt");
+            expect(typeof channel.createdAt).toBe("number");
+        });
+        expect(response).toHaveProperty("next");
+        expect(typeof response.next).toBe("string");
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call createAGroupChannel with Error", () => __awaiter(void 0, void 0, void 0, function* () {
+        const CHANNEL_URL = "create-group-channel-with-error-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: "integration",
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: true,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        try {
+            yield groupChannelApi.createAGroupChannel({
+                apiToken: API_TOKEN,
+                createAGroupChannelRequest: request,
+            });
+        }
+        catch (error) {
+            expect(JSON.parse(error.body).code).toBe(400111);
+        }
+    }));
+    it("call createAGroupChannel and deleteAGroupChannel", () => __awaiter(void 0, void 0, void 0, function* () {
+        const CHANNEL_URL = "create-then-delete-group-channel-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: "integration",
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const response = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        expect(response).toHaveProperty("channelUrl");
+        expect(response.channelUrl).toBe(CHANNEL_URL);
+        expect(typeof response.channelUrl).toBe("string");
+        expect(response).toHaveProperty("coverUrl");
+        expect(response.coverUrl).toBe("empty");
+        expect(typeof response.coverUrl).toBe("string");
+        expect(response).toHaveProperty("customType");
+        expect(response.customType).toBe("data");
+        expect(typeof response.customType).toBe("string");
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: response.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call getAGroupChannel", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _c, _d, _e, _f, _g, _h, _j, _k;
+        const CHANNEL_URL = "get-group-channel-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+        expect(typeof createGroupChannelresponse.channelUrl).toBe("string");
+        const groupChannelResponse = yield groupChannelApi.getAGroupChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMember: true,
+            memberActiveMode: "all",
+        });
+        const channel = groupChannelResponse;
+        expect(channel).toHaveProperty("channelUrl");
+        expect(channel.channelUrl).toBe(CHANNEL_URL);
+        expect(channel).toHaveProperty("channel");
+        expect(channel.channel).toBeInstanceOf(SendbirdGroupChannelDetailChannel);
+        expect(channel.channel).toHaveProperty("channelUrl");
+        expect(typeof ((_c = channel.channel) === null || _c === void 0 ? void 0 : _c.channelUrl)).toBe("string");
+        expect(channel.channel).toHaveProperty("coverUrl");
+        expect(typeof ((_d = channel.channel) === null || _d === void 0 ? void 0 : _d.coverUrl)).toBe("string");
+        expect(channel.channel).toHaveProperty("createdAt");
+        expect(typeof ((_e = channel.channel) === null || _e === void 0 ? void 0 : _e.createdAt)).toBe("number");
+        expect(channel.channel).toHaveProperty("customType");
+        expect(typeof ((_f = channel.channel) === null || _f === void 0 ? void 0 : _f.customType)).toBe("string");
+        expect(channel.channel).toHaveProperty("data");
+        expect(typeof ((_g = channel.channel) === null || _g === void 0 ? void 0 : _g.data)).toBe("string");
+        expect(channel.channel).toHaveProperty("maxLengthMessage");
+        expect(typeof ((_h = channel.channel) === null || _h === void 0 ? void 0 : _h.maxLengthMessage)).toBe("number");
+        expect(channel.channel).toHaveProperty("memberCount");
+        expect(typeof ((_j = channel.channel) === null || _j === void 0 ? void 0 : _j.memberCount)).toBe("number");
+        expect(channel.channel).toHaveProperty("name");
+        expect(typeof ((_k = channel.channel) === null || _k === void 0 ? void 0 : _k.name)).toBe("string");
+        expect(channel).toHaveProperty("name");
+        expect(typeof channel.name).toBe("string");
+        expect(channel).toHaveProperty("coverUrl");
+        expect(typeof channel.coverUrl).toBe("string");
+        expect(channel).toHaveProperty("createdAt");
+        expect(typeof channel.createdAt).toBe("number");
+        if (hasValidField(channel, "createdBy")) {
+            expect(channel.createdBy).toBeInstanceOf(SendbirdBasicUserInfo);
+        }
+        expect(channel).toHaveProperty("customType");
+        expect(typeof channel.customType).toBe("string");
+        expect(channel).toHaveProperty("data");
+        expect(typeof channel.data).toBe("string");
+        expect(channel).toHaveProperty("deliveryReceipt");
+        expect(typeof channel.deliveryReceipt).toBe("object");
+        expect(channel).toHaveProperty("disappearingMessage");
+        expect(channel.disappearingMessage).toBeInstanceOf(SendbirdDisappearingMessage);
+        expect(channel).toHaveProperty("freeze");
+        expect(typeof channel.freeze).toBe("boolean");
+        expect(channel).toHaveProperty("hasAiBot");
+        expect(typeof channel.hasAiBot).toBe("boolean");
+        expect(channel).toHaveProperty("hasBot");
+        expect(typeof channel.hasBot).toBe("boolean");
+        expect(channel).toHaveProperty("ignoreProfanityFilter");
+        expect(typeof channel.ignoreProfanityFilter).toBe("boolean");
+        expect(channel).toHaveProperty("isAccessCodeRequired");
+        expect(typeof channel.isAccessCodeRequired).toBe("boolean");
+        expect(channel).toHaveProperty("isBroadcast");
+        expect(typeof channel.isBroadcast).toBe("boolean");
+        expect(channel).toHaveProperty("isDiscoverable");
+        expect(typeof channel.isDiscoverable).toBe("boolean");
+        expect(channel).toHaveProperty("isDistinct");
+        expect(typeof channel.isDistinct).toBe("boolean");
+        expect(channel).toHaveProperty("isEphemeral");
+        expect(typeof channel.isEphemeral).toBe("boolean");
+        if ("isHidden" in channel) {
+            expect(typeof channel.isHidden).toBe("boolean");
+        }
+        if ("isMuted" in channel) {
+            expect(typeof channel.isMuted).toBe("boolean");
+        }
+        if ("isPublic" in channel) {
+            expect(typeof channel.isPublic).toBe("boolean");
+        }
+        if ("isPushEnabled" in channel) {
+            expect(typeof channel.isPushEnabled).toBe("boolean");
+        }
+        expect(channel).toHaveProperty("isSuper");
+        expect(typeof channel.isSuper).toBe("boolean");
+        expect(channel).toHaveProperty("joinedMemberCount");
+        expect(typeof channel.joinedMemberCount).toBe("number");
+        if (hasValidField(channel, "lastMessage")) {
+            expect(channel.lastMessage).toBeInstanceOf(SendbirdMessageResponse);
+        }
+        expect(channel).toHaveProperty("maxLengthMessage");
+        expect(typeof channel.maxLengthMessage).toBe("number");
+        expect(channel).toHaveProperty("memberCount");
+        expect(typeof channel.memberCount).toBe("number");
+        expect(channel).toHaveProperty("members");
+        expect(Array.isArray(channel.members)).toBe(true);
+        expect(channel).toHaveProperty("messageSurvivalSeconds");
+        expect(typeof channel.messageSurvivalSeconds).toBe("number");
+        expect(channel).toHaveProperty("name");
+        expect(typeof channel.name).toBe("string");
+        expect(channel).toHaveProperty("readReceipt");
+        expect(typeof channel.readReceipt).toBe("object");
+        expect(channel).toHaveProperty("smsFallback");
+        expect(channel.smsFallback).toBeInstanceOf(SendbirdSmsFallback);
+        expect(channel).toHaveProperty("unreadMentionCount");
+        expect(typeof channel.unreadMentionCount).toBe("number");
+        expect(channel).toHaveProperty("unreadMessageCount");
+        expect(typeof channel.unreadMessageCount).toBe("number");
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: createGroupChannelresponse.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call listMembers", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _l, _m;
+        const CHANNEL_URL = "create-group-channel-before-call-list-channels-with-then-list-members-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        expect(createGroupChannelresponse).toBeDefined();
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        const listResponse = yield groupChannelApi.listChannels({
+            apiToken: API_TOKEN,
+            limit: 1,
+            distinctMode: "all",
+            publicMode: "all",
+            superMode: "all",
+            showEmpty: true,
+            showMember: true,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMetadata: true,
+            showFrozen: true,
+        });
+        expect(listResponse).toHaveProperty("channels");
+        expect(Array.isArray(listResponse.channels)).toBe(true);
+        expect((_l = listResponse.channels) === null || _l === void 0 ? void 0 : _l.length).toBe(1);
+        const channel = (_m = listResponse.channels) === null || _m === void 0 ? void 0 : _m[0];
+        expect(channel).toBeDefined();
+        if (channel) {
+            const listMembersResponse = yield groupChannelApi.listMembers({
+                apiToken: API_TOKEN,
+                channelUrl: channel.channelUrl,
+            });
+            expect(listMembersResponse).toHaveProperty("members");
+            expect(Array.isArray(listMembersResponse.members)).toBe(true);
+            listMembersResponse.members.forEach((member) => {
+                expect(member).toHaveProperty("userId");
+                expect(typeof member.userId).toBe("string");
+                if (hasValidField(member, "deliveredTs")) {
+                    expect(typeof member.deliveredTs).toBe("number");
+                }
+                if (hasValidField(member, "doNotDisturb")) {
+                    expect(typeof member.doNotDisturb).toBe("boolean");
+                }
+                if (hasValidField(member, "friendDiscoveryKey")) {
+                    expect(Array.isArray(member.friendDiscoveryKey)).toBe(true);
+                }
+                if (hasValidField(member, "friendName")) {
+                    expect(typeof member.friendName).toBe("string");
+                }
+                if (hasValidField(member, "isActive")) {
+                    expect(typeof member.isActive).toBe("boolean");
+                }
+                if (hasValidField(member, "isBlockedByMe")) {
+                    expect(typeof member.isBlockedByMe).toBe("boolean");
+                }
+                if (hasValidField(member, "isBlockingMe")) {
+                    expect(typeof member.isBlockingMe).toBe("boolean");
+                }
+                if (hasValidField(member, "isMuted")) {
+                    expect(typeof member.isMuted).toBe("boolean");
+                }
+                if (hasValidField(member, "isOnline")) {
+                    expect(typeof member.isOnline).toBe("boolean");
+                }
+                if (hasValidField(member, "lastSeenAt")) {
+                    expect(typeof member.lastSeenAt).toBe("number");
+                }
+                if (hasValidField(member, "metadata")) {
+                    expect(typeof member.metadata).toBe("object");
+                }
+                if (hasValidField(member, "mutedDescription")) {
+                    expect(typeof member.mutedDescription).toBe("string");
+                }
+                if (hasValidField(member, "mutedEndAt")) {
+                    expect(typeof member.mutedEndAt).toBe("number");
+                }
+                if (hasValidField(member, "nickname")) {
+                    expect(typeof member.nickname).toBe("string");
+                }
+                if (hasValidField(member, "pushEnabled")) {
+                    expect(typeof member.pushEnabled).toBe("boolean");
+                }
+                if (hasValidField(member, "pushTriggerOption")) {
+                    expect(typeof member.pushTriggerOption).toBe("string");
+                }
+                if (hasValidField(member, "profileUrl")) {
+                    expect(typeof member.profileUrl).toBe("string");
+                }
+                if (hasValidField(member, "requireAuthForProfileImage")) {
+                    expect(typeof member.requireAuthForProfileImage).toBe("boolean");
+                }
+                if (hasValidField(member, "readTs")) {
+                    expect(typeof member.readTs).toBe("number");
+                }
+                if (hasValidField(member, "role")) {
+                    expect(typeof member.role).toBe("string");
+                    expect(validSendbirdMemberRoleEnum.includes(member.role)).toBe(true);
+                }
+                if (hasValidField(member, "state")) {
+                    expect(typeof member.state).toBe("string");
+                    expect(validSendbirdMemberStateEnum.includes(member.state)).toBe(true);
+                }
+            });
+        }
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call registerOperatorsToAGroupChannel, listOperators then cancelTheRegistrationOfOperators", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _o, _p, _q, _r;
+        const CHANNEL_URL = "list-operator-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+        expect(typeof createGroupChannelresponse.channelUrl).toBe("string");
+        expect(createGroupChannelresponse).toHaveProperty("operators");
+        expect(((_o = createGroupChannelresponse.operators) === null || _o === void 0 ? void 0 : _o.length) || 0).toBe(0);
+        const registerOperatorResponse = yield groupChannelApi.registerOperatorsToAGroupChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            registerOperatorsToAGroupChannelRequest: {
+                operatorIds: [MASTER_USER_ID],
+            },
+        });
+        expect(registerOperatorResponse).toBeDefined();
+        const listOperatorsResponse = yield groupChannelApi.listOperators({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+        });
+        expect(listOperatorsResponse).toHaveProperty("operators");
+        expect(Object.keys(listOperatorsResponse).length).toBe(2);
+        expect(((_p = listOperatorsResponse.operators) === null || _p === void 0 ? void 0 : _p.length) || 0).toBe(1);
+        (_q = listOperatorsResponse.operators) === null || _q === void 0 ? void 0 : _q.map((operator) => {
+            expect(operator.userId).toEqual(MASTER_USER_ID);
+            expect(operator).toHaveProperty("nickname");
+            expect(typeof operator.nickname).toBe("string");
+            expect(operator).toHaveProperty("profileUrl");
+            expect(typeof operator.profileUrl).toBe("string");
+            expect(operator).toHaveProperty("metadata");
+            expect(typeof operator.metadata).toBe("object");
+            expect(operator).toHaveProperty("requireAuthForProfileImage");
+            expect(typeof operator.requireAuthForProfileImage).toBe("boolean");
+        });
+        const cancelTheRegistrationOfOperatorsResponse = yield groupChannelApi.cancelTheRegistrationOfOperators({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            operatorIds: MASTER_USER_ID,
+        });
+        expect(cancelTheRegistrationOfOperatorsResponse).toBeDefined();
+        const listOperatorsAfterCancelRegistrationResponse = yield groupChannelApi.listOperators({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+        });
+        expect(listOperatorsAfterCancelRegistrationResponse).toHaveProperty("operators");
+        expect(Object.keys(listOperatorsAfterCancelRegistrationResponse).length).toBe(2);
+        expect(((_r = listOperatorsAfterCancelRegistrationResponse.operators) === null || _r === void 0 ? void 0 : _r.length) || 0).toBe(0);
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: createGroupChannelresponse.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call startTypingIndicators and stopTypingIndicators", () => __awaiter(void 0, void 0, void 0, function* () {
+        const CHANNEL_URL = "group-channel-typing-indicators-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+        const startTypingResponse = yield groupChannelApi.startTypingIndicators({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            startTypingIndicatorsRequest: {
+                userIds: [MASTER_USER_ID],
+            },
+        });
+        const stopTypingResponse = yield groupChannelApi.startTypingIndicators({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            startTypingIndicatorsRequest: {
+                userIds: [MASTER_USER_ID],
+            },
+        });
+        expect(startTypingResponse).toBeDefined();
+        expect(stopTypingResponse).toBeDefined();
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: createGroupChannelresponse.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call hideAChannel then unhideAChannel", () => __awaiter(void 0, void 0, void 0, function* () {
+        const CHANNEL_URL = "group-channel-hide-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: {
+                MASTER_USER_ID: "joined",
+            },
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+        const hideAChannelResponse = yield groupChannelApi.hideAChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            hideAChannelRequest: {
+                userId: SECOND_USER_ID,
+                allowAutoUnhide: true,
+                shouldHideAll: false,
+            },
+        });
+        const groupChannelAfterHideResponse = yield groupChannelApi.getAGroupChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMember: true,
+            memberActiveMode: "all",
+            userId: SECOND_USER_ID,
+        });
+        const unhideAChannelResponse = yield groupChannelApi.unhideAChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            shouldUnhideAll: false,
+            userId: SECOND_USER_ID,
+        });
+        const groupChannelAfterUnHideResponse = yield groupChannelApi.getAGroupChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMember: true,
+            memberActiveMode: "all",
+            userId: SECOND_USER_ID,
+        });
+        expect(groupChannelAfterHideResponse.channelUrl).toBe(CHANNEL_URL);
+        expect(groupChannelAfterHideResponse).toHaveProperty("hiddenState");
+        expect(groupChannelAfterHideResponse.isHidden).toBeTruthy();
+        expect(groupChannelAfterHideResponse).toHaveProperty("hiddenState");
+        expect(groupChannelAfterHideResponse.hiddenState).toBe("hidden_allow_auto_unhide");
+        expect(validSendbirdGroupChannelHiddenStateEnum.includes(groupChannelAfterHideResponse.hiddenState)).toBeTruthy();
+        expect(groupChannelAfterUnHideResponse).toHaveProperty("hiddenState");
+        expect(groupChannelAfterUnHideResponse.isHidden).toBeFalsy();
+        expect(groupChannelAfterUnHideResponse).toHaveProperty("hiddenState");
+        expect(groupChannelAfterUnHideResponse.hiddenState).toBe("unhidden");
+        expect(validSendbirdGroupChannelHiddenStateEnum.includes(groupChannelAfterUnHideResponse.hiddenState)).toBeTruthy();
+        expect(hideAChannelResponse).toBeDefined();
+        expect(unhideAChannelResponse).toBeDefined();
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: createGroupChannelresponse.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call inviteAsMembers then acceptAnInvitation and checkIfMember", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _s, _t, _u, _v;
+        const CHANNEL_URL = "group-channel-member-invitation-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: {
+                MASTER_USER_ID: "joined",
+            },
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        const inviteAsMembersResponse = yield groupChannelApi.inviteAsMembers({
+            channelUrl: CHANNEL_URL,
+            apiToken: API_TOKEN,
+            inviteAsMembersRequest: {
+                inviterId: MASTER_USER_ID,
+                userIds: [SECOND_USER_ID],
+            },
+        });
+        const groupChannelAfterInviteResponse = yield groupChannelApi.getAGroupChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMember: true,
+            memberActiveMode: "all",
+            userId: SECOND_USER_ID,
+        });
+        const acceptAnInvitationResponse = yield groupChannelApi.acceptAnInvitation({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            acceptAnInvitationRequest: {
+                userId: SECOND_USER_ID,
+                accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            },
+        });
+        const checkIfMemberResponse = yield groupChannelApi.checkIfMember({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            userId: SECOND_USER_ID,
+        });
+        const groupChannelAfterJoinedResponse = yield groupChannelApi.getAGroupChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMember: true,
+            memberActiveMode: "all",
+            userId: SECOND_USER_ID,
+        });
+        expect(inviteAsMembersResponse).toHaveProperty("invitedAt");
+        expect(inviteAsMembersResponse).toHaveProperty("inviter");
+        expect((_s = inviteAsMembersResponse.inviter) === null || _s === void 0 ? void 0 : _s.userId).toBe(MASTER_USER_ID);
+        expect(inviteAsMembersResponse.inviter).toBeInstanceOf(SendbirdBasicUserInfo);
+        expect(groupChannelAfterInviteResponse).toHaveProperty("memberState");
+        expect(groupChannelAfterInviteResponse.memberState).toBe("invited");
+        expect(groupChannelAfterInviteResponse.memberCount).toBe(2);
+        expect(groupChannelAfterInviteResponse.joinedMemberCount).toBe(1);
+        expect(acceptAnInvitationResponse.joinedMemberCount).toBe(2);
+        expect((_u = (_t = acceptAnInvitationResponse.members) === null || _t === void 0 ? void 0 : _t.find((member) => (member.state = "joined"))) === null || _u === void 0 ? void 0 : _u.userId).toBe(SECOND_USER_ID);
+        expect(groupChannelAfterJoinedResponse).toHaveProperty("memberState");
+        expect(groupChannelAfterJoinedResponse).toHaveProperty("joinedTs");
+        expect((_v = groupChannelAfterJoinedResponse.joinedTs) === null || _v === void 0 ? void 0 : _v.toString().length).toBe(10);
+        expect(groupChannelAfterJoinedResponse.memberState).toBe("joined");
+        expect(groupChannelAfterJoinedResponse.memberCount).toBe(2);
+        expect(groupChannelAfterJoinedResponse.joinedMemberCount).toBe(2);
+        expect(checkIfMemberResponse).toHaveProperty("isMember");
+        expect(checkIfMemberResponse.isMember).toBeTruthy();
+        expect(typeof checkIfMemberResponse.isMember).toBe("boolean");
+        expect(checkIfMemberResponse).toHaveProperty("state");
+        expect(checkIfMemberResponse.state).toBeTruthy();
+        expect(typeof checkIfMemberResponse.state).toBe("string");
+        expect(validSendbirdGroupChannelMemberStateEnum.includes(checkIfMemberResponse.state)).toBeTruthy();
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: createGroupChannelresponse.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call joinAChannel then leaveAChannel", () => __awaiter(void 0, void 0, void 0, function* () {
+        const CHANNEL_URL = "group-channel-join-leave-channel-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: {
+                MASTER_USER_ID: "joined",
+            },
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+        const joinAChannelResponse = yield groupChannelApi.joinAChannel({
+            channelUrl: CHANNEL_URL,
+            apiToken: API_TOKEN,
+            joinAChannelRequest: {
+                userId: SECOND_USER_ID,
+                accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            },
+        });
+        const leaveAChannelResponse = yield groupChannelApi.leaveAChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            leaveAChannelRequest: {
+                shouldLeaveAll: false,
+                userIds: [SECOND_USER_ID],
+            },
+        });
+        const getAGroupChannelResponse = yield groupChannelApi.getAGroupChannel({
+            channelUrl: createGroupChannelresponse.channelUrl,
+            apiToken: API_TOKEN,
+            showDeliveryReceipt: true,
+            showReadReceipt: true,
+            showMember: true,
+            memberActiveMode: "all",
+            userId: MASTER_USER_ID,
+        });
+        expect(joinAChannelResponse.memberCount).toBe(2);
+        expect(joinAChannelResponse.joinedMemberCount).toBe(2);
+        expect(leaveAChannelResponse).toBeDefined();
+        expect(getAGroupChannelResponse.memberCount).toBe(1);
+        expect(getAGroupChannelResponse.joinedMemberCount).toBe(1);
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: createGroupChannelresponse.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call updateAGroupChannel", () => __awaiter(void 0, void 0, void 0, function* () {
+        const CHANNEL_URL = "group-channel-update-channel-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: {
+                MASTER_USER_ID: "joined",
+            },
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelResponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        expect(createGroupChannelResponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelResponse.channelUrl).toBe(CHANNEL_URL);
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        const updateAGroupChannelResponse = yield groupChannelApi.updateAGroupChannel({
+            channelUrl: CHANNEL_URL,
+            apiToken: API_TOKEN,
+            updateAGroupChannelRequest: {
+                name: "test2",
+                data: "data2",
+            },
+        });
+        expect(updateAGroupChannelResponse.name).toBe("test2");
+        expect(updateAGroupChannelResponse.data).toBe("data2");
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+    it("call resetChatHistory", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _w;
+        const CHANNEL_URL = "group-channel-reset-chat-history-test-channel-url";
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: CHANNEL_URL,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        const request = {
+            accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+            blockSdkUserChannelJoin: true,
+            channelUrl: CHANNEL_URL,
+            coverUrl: "empty",
+            customType: "data",
+            data: "data",
+            invitationStatus: Object.fromEntries(USERS.map((id) => [id, "joined"])),
+            inviterId: MASTER_USER_ID,
+            isDistinct: false,
+            isEphemeral: true,
+            isPublic: true,
+            isSuper: true,
+            name: "test",
+            operatorIds: [],
+            strict: true,
+            users: USERS.map((id) => ({ userId: id })),
+        };
+        const createGroupChannelresponse = yield groupChannelApi.createAGroupChannel({
+            apiToken: API_TOKEN,
+            createAGroupChannelRequest: request,
+        });
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+        expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+        expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+        const resetChatHistoryresponse = yield groupChannelApi.resetChatHistory({
+            apiToken: API_TOKEN,
+            channelUrl: createGroupChannelresponse.channelUrl,
+            resetChatHistoryRequest: {
+                userId: MASTER_USER_ID,
+                resetAll: true,
+            },
+        });
+        expect(resetChatHistoryresponse).toHaveProperty("tsMessageOffset");
+        expect(typeof resetChatHistoryresponse.tsMessageOffset).toBe("number");
+        expect((_w = resetChatHistoryresponse.tsMessageOffset) === null || _w === void 0 ? void 0 : _w.toString().length).toBe(13);
+        try {
+            yield groupChannelApi.deleteAGroupChannel({
+                channelUrl: createGroupChannelresponse.channelUrl,
+                apiToken: API_TOKEN,
+            });
+        }
+        catch (e) {
+            console.warn("ignore error in cleanup", e);
+        }
+    }));
+});
+//# sourceMappingURL=groupChannel.test.js.map