"use strict";
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
const Vue = require("vue");
const index = require("../../../locales/index.js");
const index$1 = require("../../common/base/Input/index.js");
const index$2 = require("../../common/base/Select/index.js");
const index$3 = require("../../common/base/Option/index.js");
const index$6 = require("../../common/base/Checkbox/index.js");
const Button = require("../../common/base/Button.vue.js");
const Avatar = require("../../common/Avatar.vue.js");
const index$4 = require("../../common/base/Datepicker/index.js");
const index$5 = require("../../common/base/Timepicker/index.js");
const DurationTimePicker_vue_vue_type_script_setup_true_lang = require("../DurationTimePicker.vue.js");
const TimezonePicker_vue_vue_type_script_setup_true_lang = require("../TimezonePicker.vue.js");
const ShareLink = require("../ShareLink.vue.js");
const Contacts = require("../Contacts.vue.js");
const ScheduleAttendees = require("../../common/icons/ScheduleAttendees.vue.js");
const PanelContainer = require("../PanelContainer.vue.js");
const CloseIcon = require("../../common/icons/CloseIcon.vue.js");
const HideContentIcon = require("../../common/icons/HideContentIcon.vue.js");
const ShowContentIcon = require("../../common/icons/ShowContentIcon.vue.js");
require("../../../services/main.js");
const roomService = require("../../../services/roomService.js");
const types = require("../../../services/types.js");
const TUIRoomEngine = require("@tencentcloud/tuiroom-engine-js");
require("mitt");
require("../../../services/manager/roomActionManager.js");
require("@tencentcloud/tui-core");
const room = require("../../../constants/room.js");
const utils = require("../../../utils/utils.js");
const scheduleUtils = require("../scheduleUtils.js");
const SvgIcon = require("../../common/base/SvgIcon.vue.js");
const _hoisted_1 = { class: "schedule-conference-form" };
const _hoisted_2 = { class: "form-item" };
const _hoisted_3 = { class: "form-label" };
const _hoisted_4 = {
  key: 0,
  class: "form-item"
};
const _hoisted_5 = { class: "form-label" };
const _hoisted_6 = { class: "form-value" };
const _hoisted_7 = { class: "form-item" };
const _hoisted_8 = { class: "form-label" };
const _hoisted_9 = { class: "form-value" };
const _hoisted_10 = { class: "form-item" };
const _hoisted_11 = { class: "form-label" };
const _hoisted_12 = { class: "form-value" };
const _hoisted_13 = { class: "form-item" };
const _hoisted_14 = { class: "form-label" };
const _hoisted_15 = { class: "form-value" };
const _hoisted_16 = { class: "form-item column" };
const _hoisted_17 = { class: "form-label" };
const _hoisted_18 = { class: "form-value" };
const _hoisted_19 = ["title"];
const _hoisted_20 = { class: "form-attendees" };
const _hoisted_21 = ["title"];
const _hoisted_22 = {
  key: 0,
  class: "form-attendees-item",
  style: { "flex-basis": "content" }
};
const _hoisted_23 = {
  key: 1,
  class: "form-item column",
  style: { "align-items": "baseline" }
};
const _hoisted_24 = { class: "form-label" };
const _hoisted_25 = { class: "password-container" };
const _hoisted_26 = { class: "form-title" };
const _hoisted_27 = {
  key: 2,
  class: "form-item column"
};
const _hoisted_28 = { class: "form-label" };
const _hoisted_29 = { class: "form-value" };
const _hoisted_30 = { class: "checkbox-group" };
const _hoisted_31 = { class: "schedule-conference-footer" };
const _sfc_main = /* @__PURE__ */ Vue.defineComponent({
  __name: "ScheduleConferencePanelPC",
  props: {
    userName: {},
    visible: { type: Boolean },
    conferenceInfo: {}
  },
  emits: ["input"],
  setup(__props, { emit: __emit }) {
    const { t } = index.useI18n();
    const shareLinkData = Vue.ref({});
    const props = __props;
    const emit = __emit;
    const isDialogVisible = Vue.ref(false);
    const contactsVisible = Vue.ref(false);
    const showRoomInvite = Vue.ref(false);
    const isShowPassword = Vue.ref(false);
    const passwordChecked = Vue.ref(false);
    const isEditMode = Vue.computed(() => !!props.conferenceInfo);
    const roomId = Vue.ref("");
    let contacts = [];
    const { date: startDate, laterTime: startTime } = scheduleUtils.getDateAndTime(/* @__PURE__ */ new Date());
    const defaultFormData = Vue.ref({
      roomName: t("sb temporary room", {
        name: props.userName || roomService.roomService.basicStore.userId
      }),
      roomMode: "FreeToSpeak",
      startDate,
      startTime,
      duration: 1800,
      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
      searchUser: "",
      scheduleAttendees: [],
      isMicrophoneDisableForAllUser: false,
      isScreenShareDisableForAllUser: false,
      isCameraDisableForAllUser: false,
      password: `${Math.floor(Math.random() * 9e5) + 1e5}`
    });
    const form = Vue.ref(utils.deepClone(defaultFormData.value));
    const inputType = Vue.computed(() => isShowPassword.value ? "text" : "password");
    const toggleShowPassword = () => {
      isShowPassword.value = !isShowPassword.value;
    };
    const resetData = () => {
      defaultFormData.value.startDate = form.value.startDate;
      defaultFormData.value.startTime = form.value.startTime;
      form.value = Object.assign({}, utils.deepClone(defaultFormData.value));
    };
    Vue.watch(
      () => props.visible,
      async (val) => {
        isDialogVisible.value = val;
        if (val) {
          const { date, laterTime } = scheduleUtils.getDateAndTime(/* @__PURE__ */ new Date());
          form.value.roomName = t("sb temporary room", {
            name: props.userName || roomService.roomService.basicStore.userId
          });
          form.value.startDate = date;
          form.value.startTime = laterTime;
          contacts = await roomService.roomService.scheduleConferenceManager.fetchFriendList();
          isEditMode.value && (form.value = Object.assign({}, utils.deepClone(editParams.value)));
        }
      },
      {
        immediate: true
      }
    );
    const updateDialogVisible = (val) => {
      emit("input", val);
      if (!val) {
        passwordChecked.value = false;
        isShowPassword.value = false;
        resetData();
      }
    };
    Vue.watch(
      isDialogVisible,
      (val) => {
        updateDialogVisible(val);
      },
      { immediate: true }
    );
    const editParams = Vue.computed(() => {
      if (!props.conferenceInfo) return {};
      const {
        basicRoomInfo,
        scheduleAttendees,
        scheduleStartTime,
        scheduleEndTime
      } = props.conferenceInfo;
      const { date, time } = scheduleUtils.getDateAndTime(new Date(scheduleStartTime * 1e3));
      const {
        roomName,
        isSeatEnabled,
        isMicrophoneDisableForAllUser,
        isScreenShareDisableForAllUser,
        isCameraDisableForAllUser,
        password
      } = basicRoomInfo;
      return {
        roomName,
        roomMode: isSeatEnabled ? "SpeakAfterTakingSeat" : "FreeToSpeak",
        startDate: date,
        startTime: time,
        duration: scheduleEndTime - scheduleStartTime,
        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
        searchUser: "",
        scheduleAttendees,
        isMicrophoneDisableForAllUser,
        isScreenShareDisableForAllUser,
        isCameraDisableForAllUser,
        password
      };
    });
    const scheduleParams = Vue.computed(() => {
      const { startDate: startDate2, startTime: startTime2, timezone, duration, scheduleAttendees } = form.value;
      const scheduleStartTime = scheduleUtils.convertToTimestamp(startDate2, startTime2, timezone);
      const scheduleEndTime = scheduleUtils.calculateEndTime(scheduleStartTime, duration);
      return {
        roomId: roomId.value,
        scheduleStartTime: scheduleStartTime / 1e3,
        scheduleEndTime: scheduleEndTime / 1e3,
        scheduleAttendees,
        roomName: form.value.roomName,
        isSeatEnabled: form.value.roomMode !== "FreeToSpeak",
        seatMode: form.value.roomMode === "SpeakAfterTakingSeat" ? TUIRoomEngine.TUISeatMode.kApplyToTake : void 0,
        isMicrophoneDisableForAllUser: form.value.isMicrophoneDisableForAllUser,
        isScreenShareDisableForAllUser: form.value.isScreenShareDisableForAllUser,
        isCameraDisableForAllUser: form.value.isCameraDisableForAllUser,
        password: form.value.password
      };
    });
    const roomPasswordCheck = () => {
      if (!passwordChecked.value) {
        form.value.password = "";
        return true;
      }
      const { password } = form.value;
      if (!props.visible || password === "" || !utils.isDigitsOnly(password) || utils.calculateByteLength(password) < room.PASSWORD_MAX_LENGTH_LIMIT) {
        roomService.roomService.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
          type: "warning",
          message: t("Your room password format is incorrect, please check it")
        });
        return false;
      }
      return true;
    };
    const timeCheck = () => {
      if (!props.visible) return true;
      const { timezone, startDate: startDate2, startTime: startTime2 } = form.value;
      const scheduleStartTime = scheduleUtils.convertToTimestamp(startDate2, startTime2, timezone);
      const currentDate = /* @__PURE__ */ new Date();
      currentDate.setMilliseconds(0);
      currentDate.setSeconds(0);
      const currentTime = currentDate.getTime();
      const result = scheduleStartTime >= currentTime;
      !result && roomService.roomService.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
        type: "warning",
        message: t("The start time cannot be earlier than the current time")
      });
      return result;
    };
    const roomNameCheck = () => {
      if (!props.visible) return true;
      if (form.value.roomName === "") {
        roomService.roomService.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
          type: "warning",
          message: t("The room name cannot be empty")
        });
        return false;
      }
      const result = utils.calculateByteLength(form.value.roomName) <= 100;
      !result && roomService.roomService.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
        type: "warning",
        message: t("The room name cannot exceed 100 characters")
      });
      return result;
    };
    const roomStatusCheck = () => {
      var _a;
      if (!props.visible) return true;
      const isNotStarted = ((_a = props.conferenceInfo) == null ? void 0 : _a.status) === TUIRoomEngine.TUIConferenceStatus.kConferenceStatusNotStarted;
      !isNotStarted && roomService.roomService.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
        type: "warning",
        message: t(
          "The meeting is in progress and any meeting information cannot be modified"
        )
      });
      return isNotStarted;
    };
    Vue.watch(
      () => form.value.startTime,
      async (newValue, oldValue) => {
        if (!timeCheck()) {
          await Vue.nextTick();
          form.value.startTime = oldValue;
        }
      }
    );
    Vue.watch(
      () => form.value.startDate,
      async (newValue, oldValue) => {
        if (!timeCheck()) {
          await Vue.nextTick();
          form.value.startDate = oldValue;
        }
      }
    );
    Vue.watch(
      () => form.value.timezone,
      async (newValue, oldValue) => {
        const { startDate: startDate2, startTime: startTime2 } = form.value;
        const currentDate = new Date(
          scheduleUtils.convertToTimestamp(startDate2, startTime2, newValue, -1, oldValue)
        );
        const { date, laterTime } = scheduleUtils.getDateAndTime(currentDate);
        form.value.startDate = date;
        form.value.startTime = laterTime;
      }
    );
    const roomTypeList = [
      { label: "Free Speech Room", value: "FreeToSpeak" },
      { label: "On-stage Speaking Room", value: "SpeakAfterTakingSeat" }
    ];
    const selectScheduleAttends = () => {
      contactsVisible.value = true;
    };
    const searchScheduleAttend = (v) => {
      if (!v) return [];
      return contacts.filter(
        (user) => (user == null ? void 0 : user.profile.nick.includes(v)) || (user == null ? void 0 : user.userID.includes(v))
      );
    };
    const addSelectUser = (user) => {
      var _a, _b;
      form.value.searchUser = "";
      if (form.value.scheduleAttendees.findIndex(
        (item) => item.userId === user.userID
      ) !== -1)
        return;
      form.value.scheduleAttendees.push({
        userId: user.userID,
        userName: (_a = user.profile) == null ? void 0 : _a.nick,
        avatarUrl: (_b = user.profile) == null ? void 0 : _b.avatar
      });
    };
    const removeSelectUser = (user) => {
      form.value.scheduleAttendees = form.value.scheduleAttendees.filter(
        (item) => item.userId !== user.userId
      );
    };
    const contactsConfirm = (contacts2) => {
      form.value.scheduleAttendees = contacts2;
    };
    const scheduleConference = async () => {
      if (!timeCheck()) return;
      if (!roomNameCheck()) return;
      if (!roomPasswordCheck()) return;
      roomId.value = String(Math.ceil(Math.random() * 1e6));
      try {
        await roomService.roomService.scheduleConferenceManager.scheduleConference({
          ...scheduleParams.value,
          roomId: roomId.value
        });
        const userIdList = scheduleParams.value.scheduleAttendees.map(
          (item) => item.userId
        );
        if (userIdList && userIdList.length > 0) {
          await roomService.roomService.scheduleConferenceManager.addAttendeesByAdmin({
            roomId: roomId.value,
            userIdList
          });
        }
        shareLinkData.value = utils.deepClone(scheduleParams.value);
        updateDialogVisible(false);
        showRoomInvite.value = true;
      } catch (err) {
        roomService.roomService.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
          type: "error",
          message: err.message
        });
      }
    };
    const compareArrays = (oldArray, newArray, key) => {
      const added = [];
      const removed = [];
      const newKeySet = new Set(newArray.map((item) => item[key]));
      const oldKeySet = new Set(oldArray.map((item) => item[key]));
      newArray.forEach((item) => {
        if (!oldKeySet.has(item[key])) {
          added.push(item);
        }
      });
      oldArray.forEach((item) => {
        if (!newKeySet.has(item[key])) {
          removed.push(item);
        }
      });
      return {
        added,
        removed
      };
    };
    const updateConferenceInfo = async () => {
      var _a;
      if (!roomStatusCheck()) return;
      if (!timeCheck()) return;
      if (!roomNameCheck()) return;
      try {
        const roomId2 = (_a = props.conferenceInfo) == null ? void 0 : _a.basicRoomInfo.roomId;
        if (!roomId2) return;
        const { roomName, scheduleStartTime, scheduleEndTime, scheduleAttendees } = scheduleParams.value;
        await roomService.roomService.scheduleConferenceManager.updateConferenceInfo({
          roomId: roomId2,
          roomName,
          scheduleStartTime,
          scheduleEndTime
        });
        const compareResult = compareArrays(
          props.conferenceInfo.scheduleAttendees,
          scheduleAttendees,
          "userId"
        );
        await Promise.all([
          compareResult.added.length > 0 && roomService.roomService.scheduleConferenceManager.addAttendeesByAdmin({
            roomId: roomId2,
            userIdList: compareResult.added.map((item) => item.userId)
          }),
          compareResult.removed.length > 0 && roomService.roomService.scheduleConferenceManager.removeAttendeesByAdmin({
            roomId: roomId2,
            userIdList: compareResult.removed.map((item) => item.userId)
          })
        ]);
        updateDialogVisible(false);
      } catch (err) {
        roomService.roomService.emit(types.EventType.ROOM_NOTICE_MESSAGE, {
          type: "error",
          message: err.message
        });
      }
    };
    const cancel = () => {
      updateDialogVisible(false);
    };
    return (_ctx, _cache) => {
      return Vue.openBlock(), Vue.createElementBlock("div", null, [
        Vue.createVNode(PanelContainer.default, {
          visible: isDialogVisible.value,
          title: Vue.unref(t)(!isEditMode.value ? Vue.unref(t)("Schedule") : Vue.unref(t)("Modify Room")),
          onInput: _cache[11] || (_cache[11] = ($event) => isDialogVisible.value = $event)
        }, {
          footer: Vue.withCtx(() => [
            Vue.createElementVNode("div", _hoisted_31, [
              Vue.createVNode(Button.default, {
                class: "footer-button",
                type: "primary",
                onClick: cancel
              }, {
                default: Vue.withCtx(() => [
                  Vue.createTextVNode(Vue.toDisplayString(Vue.unref(t)("Cancel")), 1)
                ]),
                _: 1
              }),
              !isEditMode.value ? (Vue.openBlock(), Vue.createBlock(Button.default, {
                key: 0,
                class: "footer-button",
                onClick: scheduleConference
              }, {
                default: Vue.withCtx(() => [
                  Vue.createTextVNode(Vue.toDisplayString(Vue.unref(t)("Schedule")), 1)
                ]),
                _: 1
              })) : (Vue.openBlock(), Vue.createBlock(Button.default, {
                key: 1,
                class: "footer-button",
                onClick: updateConferenceInfo
              }, {
                default: Vue.withCtx(() => [
                  Vue.createTextVNode(Vue.toDisplayString(Vue.unref(t)("Save")), 1)
                ]),
                _: 1
              }))
            ])
          ]),
          default: Vue.withCtx(() => {
            var _a;
            return [
              Vue.createElementVNode("div", _hoisted_1, [
                Vue.createElementVNode("div", _hoisted_2, [
                  Vue.createElementVNode("span", _hoisted_3, Vue.toDisplayString(Vue.unref(t)("Room Name")), 1),
                  Vue.createVNode(Vue.unref(index$1.default), {
                    "model-value": form.value.roomName,
                    onInput: _cache[0] || (_cache[0] = ($event) => form.value.roomName = $event),
                    theme: "white",
                    class: "form-value",
                    placeholder: Vue.unref(t)("please enter the room name"),
                    maxlength: ""
                  }, null, 8, ["model-value", "placeholder"])
                ]),
                !isEditMode.value ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_4, [
                  Vue.createElementVNode("span", _hoisted_5, Vue.toDisplayString(Vue.unref(t)("Room type")), 1),
                  Vue.createElementVNode("div", _hoisted_6, [
                    Vue.createVNode(Vue.unref(index$2.default), {
                      modelValue: form.value.roomMode,
                      "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => form.value.roomMode = $event),
                      theme: "white",
                      class: "select",
                      teleported: false,
                      "popper-append-to-body": false,
                      "custom-select-content-style": { "font-weight": 400 }
                    }, {
                      default: Vue.withCtx(() => [
                        (Vue.openBlock(), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(roomTypeList, (item) => {
                          return Vue.createVNode(Vue.unref(index$3.default), {
                            key: item.value,
                            theme: "white",
                            value: item.value,
                            label: Vue.unref(t)(item.label),
                            "custom-option-content-style": { "font-weight": 400 }
                          }, null, 8, ["value", "label"]);
                        }), 64))
                      ]),
                      _: 1
                    }, 8, ["modelValue"])
                  ])
                ])) : Vue.createCommentVNode("", true),
                Vue.createElementVNode("div", _hoisted_7, [
                  Vue.createElementVNode("span", _hoisted_8, Vue.toDisplayString(Vue.unref(t)("Starting time")), 1),
                  Vue.createElementVNode("div", _hoisted_9, [
                    Vue.createVNode(Vue.unref(index$4.default), {
                      "model-value": form.value.startDate,
                      class: "date-picker",
                      onInput: _cache[2] || (_cache[2] = ($event) => form.value.startDate = $event)
                    }, null, 8, ["model-value"]),
                    Vue.createVNode(Vue.unref(index$5.default), {
                      "model-value": form.value.startTime,
                      class: "time-picker",
                      onInput: _cache[3] || (_cache[3] = ($event) => form.value.startTime = $event)
                    }, null, 8, ["model-value"])
                  ])
                ]),
                Vue.createElementVNode("div", _hoisted_10, [
                  Vue.createElementVNode("span", _hoisted_11, Vue.toDisplayString(Vue.unref(t)("Room duration")), 1),
                  Vue.createElementVNode("div", _hoisted_12, [
                    Vue.createVNode(DurationTimePicker_vue_vue_type_script_setup_true_lang.default, {
                      "model-value": form.value.duration,
                      class: "select",
                      onInput: _cache[4] || (_cache[4] = ($event) => form.value.duration = $event)
                    }, null, 8, ["model-value"])
                  ])
                ]),
                Vue.createElementVNode("div", _hoisted_13, [
                  Vue.createElementVNode("span", _hoisted_14, Vue.toDisplayString(Vue.unref(t)("Time zone")), 1),
                  Vue.createElementVNode("div", _hoisted_15, [
                    Vue.createVNode(TimezonePicker_vue_vue_type_script_setup_true_lang.default, {
                      "model-value": form.value.timezone,
                      class: "select",
                      onInput: _cache[5] || (_cache[5] = ($event) => form.value.timezone = $event)
                    }, null, 8, ["model-value"])
                  ])
                ]),
                Vue.createElementVNode("div", _hoisted_16, [
                  Vue.createElementVNode("span", _hoisted_17, Vue.toDisplayString(Vue.unref(t)("Attendees")), 1),
                  Vue.createElementVNode("div", _hoisted_18, [
                    Vue.createVNode(Vue.unref(index$1.default), {
                      "model-value": form.value.searchUser,
                      onInput: _cache[6] || (_cache[6] = ($event) => form.value.searchUser = $event),
                      class: "form-input search-user",
                      search: searchScheduleAttend,
                      select: addSelectUser,
                      placeholder: Vue.unref(t)("Please enter the member name")
                    }, {
                      suffixIcon: Vue.withCtx(() => [
                        Vue.createVNode(SvgIcon.default, {
                          onClick: selectScheduleAttends,
                          icon: ScheduleAttendees.default,
                          class: Vue.normalizeClass(["select-attendees"])
                        })
                      ]),
                      searchResultItem: Vue.withCtx(({ data }) => [
                        Vue.createVNode(Avatar.default, {
                          class: "form-attendees-item-avatar",
                          "img-src": data.profile.avatar
                        }, null, 8, ["img-src"]),
                        Vue.createElementVNode("p", {
                          class: "form-attendees-item-name",
                          title: data.profile.nick
                        }, Vue.toDisplayString(data.profile.nick), 9, _hoisted_19)
                      ]),
                      _: 1
                    }, 8, ["model-value", "placeholder"]),
                    Vue.createElementVNode("div", _hoisted_20, [
                      (Vue.openBlock(true), Vue.createElementBlock(Vue.Fragment, null, Vue.renderList(form.value.scheduleAttendees, (user) => {
                        return Vue.openBlock(), Vue.createElementBlock("span", {
                          key: user.userId,
                          class: "form-attendees-item"
                        }, [
                          Vue.createVNode(Avatar.default, {
                            class: "form-attendees-item-avatar",
                            "img-src": user.avatarUrl
                          }, null, 8, ["img-src"]),
                          Vue.createElementVNode("p", {
                            class: "form-attendees-item-name",
                            title: user.userName
                          }, Vue.toDisplayString(user.userName), 9, _hoisted_21),
                          Vue.createVNode(CloseIcon.default, {
                            class: "form-attendees-item-remove",
                            onClick: ($event) => removeSelectUser(user)
                          }, null, 8, ["onClick"])
                        ]);
                      }), 128)),
                      ((_a = form.value.scheduleAttendees) == null ? void 0 : _a.length) > 0 ? (Vue.openBlock(), Vue.createElementBlock("span", _hoisted_22, Vue.toDisplayString(`${form.value.scheduleAttendees.length} ${Vue.unref(t)("people")}`), 1)) : Vue.createCommentVNode("", true)
                    ])
                  ])
                ]),
                !isEditMode.value ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_23, [
                  Vue.createElementVNode("span", _hoisted_24, Vue.toDisplayString(Vue.unref(t)("Security")), 1),
                  Vue.createElementVNode("div", _hoisted_25, [
                    Vue.createVNode(Vue.unref(index$6.default), {
                      "model-value": form.value.passwordChecked,
                      class: "checkbox-group-item",
                      onInput: _cache[7] || (_cache[7] = ($event) => passwordChecked.value = $event)
                    }, {
                      default: Vue.withCtx(() => [
                        Vue.createElementVNode("span", _hoisted_26, Vue.toDisplayString(Vue.unref(t)("Room Password")), 1)
                      ]),
                      _: 1
                    }, 8, ["model-value"]),
                    passwordChecked.value ? (Vue.openBlock(), Vue.createBlock(Vue.unref(index$1.default), {
                      key: 0,
                      "model-value": form.value.password,
                      onInput: _cache[8] || (_cache[8] = ($event) => form.value.password = $event),
                      theme: "white",
                      class: "form-value",
                      style: { "margin-top": "8px" },
                      placeholder: Vue.unref(t)("Enter 6-digit password"),
                      maxlength: "6",
                      type: inputType.value
                    }, {
                      suffixIcon: Vue.withCtx(() => [
                        isShowPassword.value ? (Vue.openBlock(), Vue.createBlock(SvgIcon.default, {
                          key: 0,
                          class: "icon",
                          onClick: toggleShowPassword,
                          icon: ShowContentIcon.default
                        })) : (Vue.openBlock(), Vue.createBlock(SvgIcon.default, {
                          key: 1,
                          class: "icon",
                          onClick: toggleShowPassword,
                          icon: HideContentIcon.default
                        }))
                      ]),
                      _: 1
                    }, 8, ["model-value", "placeholder", "type"])) : Vue.createCommentVNode("", true)
                  ])
                ])) : Vue.createCommentVNode("", true),
                !isEditMode.value ? (Vue.openBlock(), Vue.createElementBlock("div", _hoisted_27, [
                  Vue.createElementVNode("span", _hoisted_28, Vue.toDisplayString(Vue.unref(t)("Member management")), 1),
                  Vue.createElementVNode("div", _hoisted_29, [
                    Vue.createElementVNode("div", _hoisted_30, [
                      Vue.createVNode(Vue.unref(index$6.default), {
                        "model-value": form.value.isMicrophoneDisableForAllUser,
                        class: "checkbox-group-item",
                        onInput: _cache[9] || (_cache[9] = ($event) => form.value.isMicrophoneDisableForAllUser = $event)
                      }, {
                        default: Vue.withCtx(() => [
                          Vue.createElementVNode("span", null, Vue.toDisplayString(Vue.unref(t)("Disable all audios")), 1)
                        ]),
                        _: 1
                      }, 8, ["model-value"]),
                      Vue.createVNode(Vue.unref(index$6.default), {
                        "model-value": form.value.isCameraDisableForAllUser,
                        class: "checkbox-group-item",
                        onInput: _cache[10] || (_cache[10] = ($event) => form.value.isCameraDisableForAllUser = $event)
                      }, {
                        default: Vue.withCtx(() => [
                          Vue.createTextVNode(Vue.toDisplayString(Vue.unref(t)("Disable all videos")), 1)
                        ]),
                        _: 1
                      }, 8, ["model-value"])
                    ])
                  ])
                ])) : Vue.createCommentVNode("", true)
              ])
            ];
          }),
          _: 1
        }, 8, ["visible", "title"]),
        Vue.createVNode(Contacts.default, {
          visible: contactsVisible.value,
          contacts: Vue.unref(contacts),
          "selected-list": scheduleParams.value.scheduleAttendees,
          onInput: _cache[12] || (_cache[12] = ($event) => contactsVisible.value = $event),
          onConfirm: contactsConfirm
        }, null, 8, ["visible", "contacts", "selected-list"]),
        Vue.createVNode(ShareLink.default, {
          visible: showRoomInvite.value,
          "schedule-params": shareLinkData.value,
          onInput: _cache[13] || (_cache[13] = ($event) => showRoomInvite.value = $event)
        }, null, 8, ["visible", "schedule-params"])
      ]);
    };
  }
});
exports.default = _sfc_main;
