@sendbird/sendbird-platform-sdk-typescript 2.0.0 → 2.1.1

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

@@ -1,1238 +0,0 @@
-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