// Module ID: 5243
// Function ID: 5244
// Name: AudioActionCreators
// Dependencies: [5, 5244, 5247, 2065, 2012, 5110, 2116, 1390, 1085, 5248, 5117, 3, 1265, 551, 584, 5249, 5225, 5253, 5270, 2]

// Module 5243 (AudioActionCreators)
import LoggerDefault from "Logger" /* 3 */;
import debounceDefault from "debounce" /* 551 */;
import DispatcherDefault from "Dispatcher" /* 584 */;
import AnalyticsUtilsDefault from "AnalyticsUtils" /* 1265 */;
import Constants2 from "Constants" /* 5117 */;
import trackVoiceAndVideoSettingsUpdateDefault from "trackVoiceAndVideoSettingsUpdate" /* 5225 */;
import Constants3 from "Constants" /* 5248 */;
import AudioSettingsUtils from "AudioSettingsUtils" /* 5249 */;
import applyBackgroundOption from "applyBackgroundOption" /* 5253 */;
import StreamQualityUtils from "StreamQualityUtils" /* 5270 */;
import _asyncToGenerator from "_asyncToGenerator" /* 5 */;
import SpatialAudioStore from "SpatialAudioStore" /* 5244 */;
import CertifiedDeviceStore from "CertifiedDeviceStore" /* 5247 */;
import ChannelStore from "ChannelStore" /* 2065 */;
import MediaEngineStore from "MediaEngineStore" /* 2012 */;
import RTCConnectionStore from "RTCConnectionStore" /* 5110 */;
import SelectedChannelStore from "SelectedChannelStore" /* 2116 */;
import UserStore from "UserStore" /* 1390 */;
import Constants from "Constants" /* 1085 */;
import size from "module_2" /* 2 */;

let c1, c2;

let closure_12;
let unpackModuleId;
function trackDeviceChanged(inputDevices, inputDeviceId, found, Video) {
  let getCertifiedDeviceName2;
  let type;
  if (inputDeviceId !== found) {
    const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
    let channel = null;
    if (null != voiceChannelId) {
      channel = ChannelStore.getChannel(voiceChannelId);
    }
    const mediaEngine = MediaEngineStore.getMediaEngine();
    const audioSubsystem = mediaEngine.getAudioSubsystem();
    const mediaEngine1 = MediaEngineStore.getMediaEngine();
    const audioLayer = mediaEngine1.getAudioLayer();
    let str = "";
    let str2 = "";
    const track = AnalyticsUtilsDefault.track;
    const MEDIA_DEVICE_CHANGED = constants2.MEDIA_DEVICE_CHANGED;
    const getCertifiedDeviceName = CertifiedDeviceStore.getCertifiedDeviceName;
    AnalyticsUtilsDefault;
    if (null != inputDevices[inputDeviceId]) {
      str2 = tmp6.name;
    }
    obj = { device_from_name: getCertifiedDeviceName(inputDeviceId, str2), device_to_name: getCertifiedDeviceName2(found, str), device_type: Video, device_is_certified: CertifiedDeviceStore.isCertified(found), location: tmp, location_stack: tmp2, voice_channel_type: type, audio_subsystem: audioSubsystem, audio_layer: audioLayer };
    getCertifiedDeviceName2 = obj3.getCertifiedDeviceName;
    if (null != inputDevices[found]) {
      str = tmp7.name;
    }
    type = undefined;
    if (channel != null) {
      type = channel.type;
    }
    track(MEDIA_DEVICE_CHANGED, obj);
  }
}
({ InputModes: unpackModuleId, AnalyticEvents: closure_12 } = Constants);
const SoundOutputChannel = Constants3.SoundOutputChannel;
const MediaEngineContextTypes = Constants2.MediaEngineContextTypes;
let obj = new LoggerDefault("AudioActionCreators");
obj.enableNativeLogger(true);
let closure_16 = debounceDefault((target_user_id, context, volume) => {
  obj = AnalyticsUtilsDefault;
  const obj2 = { target_user_id, context, volume, media_session_id: RTCConnectionStore.getMediaSessionId(), rtc_connection_id: RTCConnectionStore.getRTCConnectionId() };
  obj.track(constants2.USER_VOLUME_SETTING_UPDATED, obj2);
}, 300);
function isNotSupported() {
  return false;
}
function trackToggleSelfMute() {

}
function trackToggleSelfDeaf() {

}
let obj2 = {
  enable() {
    return Promise.resolve(true);
  },
  toggleSelfMute(arg0) {
    obj = arg0;
    if (arg0 === undefined) {
      obj = {};
    }
    let DEFAULT = obj.context;
    if (DEFAULT === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    let flag = obj.syncRemote;
    if (flag === undefined) {
      flag = true;
    }
    if (obj.usedKeybind !== undefined) {
      let flag2 = obj.playSoundEffect;
      if (flag2 === undefined) {
        flag2 = true;
      }
      const _location = obj.location;
      if (typeof isNotSupported === "function") {
        if (typeof trackToggleSelfMute === "function") {
          let dispatchResult;
          if (flag2) {
            flag2 = !MediaEngineStore.hasActiveCallKitCall();
          }
          const currentUser = UserStore.getCurrentUser();
          let isStaffResult;
          if (currentUser != null) {
            isStaffResult = currentUser.isStaff();
          }
          if (isStaffResult) {
            obj.info("Toggling self mute");
          }
          if (MediaEngineStore.isEnabled()) {
            const obj2 = { type: "AUDIO_TOGGLE_SELF_MUTE", context: DEFAULT, syncRemote: flag, playSoundEffect: flag2 };
            const obj3 = DispatcherDefault;
            dispatchResult = obj3.dispatch(obj2);
          } else {
            const self = this;
            dispatchResult = this.enable(true);
          }
          return dispatchResult;
        } else {
          throw new TypeError("Trying to call a non-function");
        }
      } else {
        throw new TypeError("Trying to call a non-function");
      }
    }
  },
  setSelfMute(context, mute) {
    let flag = arg2;
    if (arg2 === undefined) {
      flag = true;
    }
    if (typeof isNotSupported === "function") {
      if (flag) {
        flag = !MediaEngineStore.hasActiveCallKitCall();
      }
      const currentUser = UserStore.getCurrentUser();
      let isStaffResult;
      if (currentUser != null) {
        isStaffResult = currentUser.isStaff();
      }
      if (isStaffResult) {
        obj.info("Setting self mute", mute);
      }
      obj = { type: "AUDIO_SET_SELF_MUTE", context, mute, playSoundEffect: flag };
      const obj2 = DispatcherDefault;
      obj2.dispatch(obj);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setTemporarySelfMute(mute) {
    if (typeof isNotSupported === "function") {
      const currentUser = UserStore.getCurrentUser();
      let isStaffResult;
      if (currentUser != null) {
        isStaffResult = currentUser.isStaff();
      }
      if (isStaffResult) {
        obj.info("Setting temporary self mute", mute);
      }
      obj = { type: "AUDIO_SET_TEMPORARY_SELF_MUTE", mute };
      const obj2 = DispatcherDefault;
      obj2.dispatch(obj);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  toggleSelfDeaf(arg0) {
    obj = arg0;
    if (arg0 === undefined) {
      obj = {};
    }
    let DEFAULT = obj.context;
    if (DEFAULT === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    let flag = obj.syncRemote;
    if (flag === undefined) {
      flag = true;
    }
    if (obj.usedKeybind !== undefined) {
      const _location = obj.location;
      if (typeof isNotSupported === "function") {
        if (typeof trackToggleSelfDeaf === "function") {
          const obj3 = { type: "AUDIO_TOGGLE_SELF_DEAF", context: DEFAULT, syncRemote: flag };
          const obj2 = DispatcherDefault;
          obj2.dispatch(obj3);
        } else {
          throw new TypeError("Trying to call a non-function");
        }
      } else {
        throw new TypeError("Trying to call a non-function");
      }
    }
  },
  toggleLocalMute(id, arg1) {
    let DEFAULT = arg1;
    if (arg1 === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_TOGGLE_LOCAL_MUTE", context: DEFAULT, userId: id };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  toggleLocalSoundboardMute(id) {
    let DEFAULT = arg1;
    if (arg1 === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    obj = DispatcherDefault;
    const obj2 = { type: "AUDIO_TOGGLE_LOCAL_SOUNDBOARD_MUTE", context: DEFAULT, userId: id };
    obj.dispatch(obj2);
  },
  setDisableLocalVideo(id, MANUAL_ENABLED, DEFAULT, arg3) {
    if (DEFAULT === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    let flag = arg3;
    if (arg3 === undefined) {
      flag = true;
    }
    let flag2 = arg4;
    if (arg4 === undefined) {
      flag2 = false;
    }
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_LOCAL_VIDEO_DISABLED", context: DEFAULT, userId: id, videoToggleState: MANUAL_ENABLED, persist: flag, isAutomatic: flag2 };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setLocalVolume(userId, USER, DEFAULT) {
    if (DEFAULT === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    obj = AudioSettingsUtils;
    const snapVolumeToDefaultResult = obj.snapVolumeToDefault(USER, DEFAULT);
    const obj2 = DispatcherDefault;
    const obj3 = { type: "AUDIO_SET_LOCAL_VOLUME", context: DEFAULT, userId, volume: snapVolumeToDefaultResult };
    obj2.dispatch(obj3);
    closure_16(userId, DEFAULT, snapVolumeToDefaultResult);
  },
  setSpatialAudioOverrides(overrides) {
    obj = DispatcherDefault;
    const obj2 = { type: "AUDIO_SET_SPATIAL_AUDIO_OVERRIDES", overrides };
    obj.dispatch(obj2);
  },
  setSpatialAudioEnabled(enabled) {
    obj = DispatcherDefault;
    const obj2 = { type: "AUDIO_SET_SPATIAL_AUDIO_ENABLED", enabled };
    obj.dispatch(obj2);
  },
  setSpatialAudio(arg0, arg1) {
    if (typeof isNotSupported === "function") {
      const self = this;
      const result = SpatialAudioStore.isSpatialAudioEnabled();
      trackVoiceAndVideoSettingsUpdateDefault("spatial_audio_enabled", arg0, result, arg1);
      const result1 = this.setSpatialAudioEnabled(arg0);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setLocalPan(userId, left, right) {
    let DEFAULT = arg3;
    if (arg3 === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    const rect = { type: "AUDIO_SET_LOCAL_PAN", context: DEFAULT, userId, left, right };
    obj = DispatcherDefault;
    obj.dispatch(rect);
  },
  setMode(mode, arg1, DEFAULT) {
    let obj5;
    let type;
    let type1;
    obj = arg1;
    if (arg1 === undefined) {
      obj = {};
    }
    if (DEFAULT === undefined) {
      DEFAULT = MediaEngineContextTypes.DEFAULT;
    }
    let obj2 = arg3;
    if (arg3 === undefined) {
      obj2 = {};
    }
    const analyticsLocations = obj2.analyticsLocations;
    if (typeof isNotSupported === "function") {
      mode = MediaEngineStore.getMode();
      const modeOptions = MediaEngineStore.getModeOptions(DEFAULT);
      const obj4 = { type: "AUDIO_SET_MODE", context: DEFAULT, mode, options: obj5 };
      obj5 = {};
      const dispatch = DispatcherDefault.dispatch;
      DispatcherDefault;
      const merged = Object.assign(modeOptions);
      const merged1 = Object.assign(obj);
      dispatch(obj4);
      if (mode !== mode) {
        const mediaEngine = obj3.getMediaEngine();
        const audioSubsystem = mediaEngine.getAudioSubsystem();
        const mediaEngine1 = obj3.getMediaEngine();
        const audioLayer = mediaEngine1.getAudioLayer();
        const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
        let channel = null;
        if (null != voiceChannelId) {
          channel = ChannelStore.getChannel(voiceChannelId);
        }
        const inputDevices = obj3.getInputDevices();
        const tmp31 = inputDevices[MediaEngineStore.getInputDeviceId(MediaEngineStore)];
        let str2 = "";
        if (null != tmp31) {
          str2 = tmp31.name;
        }
        const obj6 = { mode, location_stack: analyticsLocations, voice_channel_type: type, input_device_name: str2, audio_subsystem: audioSubsystem, audio_layer: audioLayer };
        type = undefined;
        const track2 = AnalyticsUtilsDefault.track;
        const VOICE_ACTIVATION_MODE_CHANGED = constants2.VOICE_ACTIVATION_MODE_CHANGED;
        AnalyticsUtilsDefault;
        if (channel != null) {
          type = channel.type;
        }
        track2(VOICE_ACTIVATION_MODE_CHANGED, obj6);
      } else if (mode === unpackModuleId.VOICE_ACTIVITY) {
        if (modeOptions !== obj) {
          const mediaEngine2 = obj3.getMediaEngine();
          const audioSubsystem1 = mediaEngine2.getAudioSubsystem();
          const mediaEngine3 = obj3.getMediaEngine();
          const audioLayer1 = mediaEngine3.getAudioLayer();
          const voiceChannelId1 = SelectedChannelStore.getVoiceChannelId();
          let channel1 = null;
          if (null != voiceChannelId1) {
            channel1 = ChannelStore.getChannel(voiceChannelId1);
          }
          const inputDevices1 = obj3.getInputDevices();
          const tmp18 = inputDevices1[MediaEngineStore.getInputDeviceId(MediaEngineStore)];
          let str = "";
          if (null != tmp18) {
            str = tmp18.name;
          }
          const obj7 = { location_stack: analyticsLocations, voice_channel_type: type1, input_device_name: str, audio_subsystem: audioSubsystem1, audio_layer: audioLayer1, old_threshold: modeOptions.threshold, new_threshold: obj.threshold, old_auto_threshold: modeOptions.autoThreshold, new_auto_threshold: obj.autoThreshold };
          type1 = undefined;
          const track = AnalyticsUtilsDefault.track;
          const VOICE_ACTIVITY_THRESHOLD_CHANGED = constants2.VOICE_ACTIVITY_THRESHOLD_CHANGED;
          AnalyticsUtilsDefault;
          if (channel1 != null) {
            type1 = channel1.type;
          }
          track(VOICE_ACTIVITY_THRESHOLD_CHANGED, obj7);
        }
      }
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setBypassSystemInputProcessing(bypassEnabled, location) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_BYPASS_SYSTEM_INPUT_PROCESSING", bypassEnabled, location };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setInputVolume(volume) {
    let type;
    if (typeof isNotSupported === "function") {
      const obj3 = { type: "AUDIO_SET_INPUT_VOLUME", volume };
      const obj2 = DispatcherDefault;
      obj2.dispatch(obj3);
      const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
      let channel = null;
      if (null != voiceChannelId) {
        channel = ChannelStore.getChannel(voiceChannelId);
      }
      const obj4 = { volume, location_stack: tmp, voice_channel_type: type };
      type = undefined;
      const track = tmp3(1265).track;
      const MEDIA_INPUT_VOLUME_CHANGED = constants2.MEDIA_INPUT_VOLUME_CHANGED;
      AnalyticsUtilsDefault;
      if (channel != null) {
        type = channel.type;
      }
      track(MEDIA_INPUT_VOLUME_CHANGED, obj4);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setOutputVolume(volume) {
    let type;
    if (typeof isNotSupported === "function") {
      const obj3 = { type: "AUDIO_SET_OUTPUT_VOLUME", volume };
      const obj2 = DispatcherDefault;
      obj2.dispatch(obj3);
      const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
      let channel = null;
      if (null != voiceChannelId) {
        channel = ChannelStore.getChannel(voiceChannelId);
      }
      const obj4 = { volume, location_stack: tmp, voice_channel_type: type };
      type = undefined;
      const track = tmp3(1265).track;
      const MEDIA_OUTPUT_VOLUME_CHANGED = constants2.MEDIA_OUTPUT_VOLUME_CHANGED;
      AnalyticsUtilsDefault;
      if (channel != null) {
        type = channel.type;
      }
      track(MEDIA_OUTPUT_VOLUME_CHANGED, obj4);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setInputDevice(id) {
    let _location;
    let analyticsLocations;
    obj = arg1;
    if (arg1 === undefined) {
      obj = {};
    }
    ({ location: _location, analyticsLocations } = obj);
    if (typeof isNotSupported === "function") {
      const inputDeviceId = MediaEngineStore.getInputDeviceId();
      const obj2 = MediaEngineStore;
      if (null != _location) {
        const obj3 = { location: _location, analyticsLocations };
        trackDeviceChanged(obj2.getInputDevices(), inputDeviceId, id, "Audio Input", obj3);
      }
      const obj5 = { type: "AUDIO_SET_INPUT_DEVICE", id, oldId: inputDeviceId };
      const obj4 = DispatcherDefault;
      obj4.dispatch(obj5);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setOutputDevice(id) {
    let _location;
    let analyticsLocations;
    obj = arg1;
    if (arg1 === undefined) {
      obj = {};
    }
    ({ location: _location, analyticsLocations } = obj);
    if (typeof isNotSupported === "function") {
      const outputDeviceId = MediaEngineStore.getOutputDeviceId();
      const obj2 = MediaEngineStore;
      if (null != _location) {
        const obj3 = { location: _location, analyticsLocations };
        trackDeviceChanged(obj2.getOutputDevices(), outputDeviceId, id, "Audio Output", obj3);
      }
      const obj5 = { type: "AUDIO_SET_OUTPUT_DEVICE", id, oldId: outputDeviceId };
      const obj4 = DispatcherDefault;
      obj4.dispatch(obj5);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setVideoDevice(found) {
    let _location;
    let analyticsLocations;
    obj = arg1;
    if (arg1 === undefined) {
      obj = {};
    }
    ({ location: _location, analyticsLocations } = obj);
    if (typeof isNotSupported === "function") {
      const videoDeviceId = MediaEngineStore.getVideoDeviceId();
      const obj2 = MediaEngineStore;
      if (null != _location) {
        const obj3 = { location: _location, analyticsLocations };
        trackDeviceChanged(obj2.getVideoDevices(), videoDeviceId, found, "Video", obj3);
      }
      const obj5 = { type: "MEDIA_ENGINE_SET_VIDEO_DEVICE", id: found, oldId: videoDeviceId };
      const obj4 = DispatcherDefault;
      obj4.dispatch(obj5);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setActiveInputProfile(inputProfile) {
    obj = arg1;
    if (arg1 === undefined) {
      obj = {};
    }
    const analyticsLocations = obj.analyticsLocations;
    if (typeof isNotSupported === "function") {
      const tmp3 = trackVoiceAndVideoSettingsUpdateDefault;
      const activeInputProfile = MediaEngineStore.getActiveInputProfile();
      tmp3("active_input_profile", inputProfile, activeInputProfile, analyticsLocations);
      const obj2 = { type: "AUDIO_SET_ACTIVE_INPUT_PROFILE", inputProfile };
      const tmpResult = DispatcherDefault;
      tmpResult.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setEchoCancellation(enabled, location) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_ECHO_CANCELLATION", enabled, location };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setSidechainCompression(enabled) {
    obj = arg1;
    if (arg1 === undefined) {
      obj = {};
    }
    const analyticsLocations = obj.analyticsLocations;
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("stream_attenuation_enabled", enabled, MediaEngineStore.getSidechainCompression(), analyticsLocations);
      const obj3 = { type: "AUDIO_SET_SIDECHAIN_COMPRESSION", enabled };
      const obj2 = DispatcherDefault;
      obj2.dispatch(obj3);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setSidechainCompressionStrength(strength) {
    obj = arg1;
    if (arg1 === undefined) {
      obj = {};
    }
    const analyticsLocations = obj.analyticsLocations;
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("stream_attenuation_strength", strength, MediaEngineStore.getSidechainCompressionStrength(), analyticsLocations);
      const obj3 = { type: "AUDIO_SET_SIDECHAIN_COMPRESSION_STRENGTH", strength };
      const obj2 = DispatcherDefault;
      obj2.dispatch(obj3);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setLoopback(loopbackReason, enabled) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_LOOPBACK", loopbackReason, enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setNoiseSuppression(enabled, location) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_NOISE_SUPPRESSION", enabled, location };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setNoiseCancellation(enabled, location) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_NOISE_CANCELLATION", enabled, location };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
      const obj4 = { type: "AUDIO_SET_NOISE_SUPPRESSION", enabled: !enabled, location };
      const obj3 = DispatcherDefault;
      obj3.dispatch(obj4);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setAutomaticGainControl(enabled, location) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_AUTOMATIC_GAIN_CONTROL", enabled, location };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setAttenuation(attenuation, attenuateWhileSpeakingSelf, attenuateWhileSpeakingOthers) {
    if (typeof isNotSupported === "function") {
      attenuation = MediaEngineStore.getAttenuation();
      attenuateWhileSpeakingSelf = MediaEngineStore.getAttenuateWhileSpeakingSelf();
      attenuateWhileSpeakingOthers = MediaEngineStore.getAttenuateWhileSpeakingOthers();
      if (attenuation !== attenuation) {
        trackVoiceAndVideoSettingsUpdateDefault("global_attenuation_strength", attenuation, attenuation);
      } else if (attenuateWhileSpeakingSelf !== attenuateWhileSpeakingSelf) {
        trackVoiceAndVideoSettingsUpdateDefault("global_attenuation_for_self_speak_enabled", attenuateWhileSpeakingSelf, attenuateWhileSpeakingSelf);
      } else if (attenuateWhileSpeakingOthers !== attenuateWhileSpeakingOthers) {
        trackVoiceAndVideoSettingsUpdateDefault("global_attenuation_for_other_speak_enabled", attenuateWhileSpeakingOthers, attenuateWhileSpeakingOthers);
      }
      const obj2 = { type: "AUDIO_SET_ATTENUATION", attenuation, attenuateWhileSpeakingSelf, attenuateWhileSpeakingOthers };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setQoS(enabled) {
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("quality_of_service_packets_enabled", enabled, MediaEngineStore.getQoS());
      const obj2 = { type: "AUDIO_SET_QOS", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  reset() {
    if (typeof isNotSupported === "function") {
      obj = DispatcherDefault;
      obj.dispatch({ type: "AUDIO_RESET" });
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setSilenceWarning(enabled) {
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("silence_warning_enabled", enabled, MediaEngineStore.getEnableSilenceWarning());
      const obj2 = { type: "AUDIO_SET_DISPLAY_SILENCE_WARNING", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setDebugLogging(arg0) {
    let closure_0 = arg0;
    return (async (arg0, value) => {
      let v1;
      if (c2 === 2) {
        c2 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          const obj2 = { value, done: true };
          return obj2;
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          c2 = 2;
          if (0 === c1) {
            if (arg0 === 1) {
              c2 = 3;
              throw value;
            } else if (arg0 === 2) {
              c2 = 3;
              const obj3 = { value, done: true };
              return obj3;
            } else {
              closure_0 = tmp;
              isNotSupported();
              const tmp14 = c1(c2[16]);
              c1 = 1;
              c2 = 1;
              const obj4 = { value: tmp14("debug_logging_enabled", closure_0, debugLogging.getDebugLogging()), done: false };
              return obj4;
            }
          } else if (arg0 === 1) {
            c2 = 3;
            throw value;
          } else if (arg0 === 2) {
            c2 = 3;
            const obj5 = { value, done: true };
            return obj5;
          } else {
            const obj6 = { type: "AUDIO_SET_DEBUG_LOGGING", enabled: closure_128_0 };
            obj = c1(c2[14]);
            obj.dispatch(obj6);
            c2 = 3;
            return { value: "IconComponent", done: null };
          }
        } catch (tmp17) {
          c2 = 3;
          throw tmp17;
        }
      }
    })();
  },
  setVideoHook(enabled) {
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("video_hook_enabled", enabled, MediaEngineStore.getVideoHook());
      const obj2 = { type: "MEDIA_ENGINE_SET_VIDEO_HOOK", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setExperimentalSoundshare(enabled) {
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("experimental_soundshare_enabled", enabled, MediaEngineStore.getExperimentalSoundshare());
      const obj2 = { type: "MEDIA_ENGINE_SET_EXPERIMENTAL_SOUNDSHARE", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setUseSystemScreensharePicker(enabled) {
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("system_screenshare_picker_enabled", enabled, MediaEngineStore.getUseSystemScreensharePicker());
      const obj2 = { type: "MEDIA_ENGINE_SET_USE_SYSTEM_SCREENSHARE_PICKER", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setAudioSubsystem(arg0) {
    let closure_0 = arg0;
    return (async (arg0, value) => {
      let v1;
      if (c2 === 2) {
        c2 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          const obj2 = { value, done: true };
          return obj2;
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          c2 = 2;
          if (0 === c1) {
            if (arg0 === 1) {
              c2 = 3;
              throw value;
            } else if (arg0 === 2) {
              c2 = 3;
              const obj3 = { value, done: true };
              return obj3;
            } else {
              closure_0 = tmp;
              isNotSupported();
              const tmp14 = c1(c2[16]);
              c1 = 1;
              c2 = 1;
              const obj4 = { value: tmp14("audio_subsystem", closure_0, audioSubsystem.getAudioSubsystem()), done: false };
              return obj4;
            }
          } else if (arg0 === 1) {
            c2 = 3;
            throw value;
          } else if (arg0 === 2) {
            c2 = 3;
            const obj5 = { value, done: true };
            return obj5;
          } else {
            const obj6 = { type: "AUDIO_SET_SUBSYSTEM", subsystem: closure_128_0 };
            obj = c1(c2[14]);
            obj.dispatch(obj6);
            c2 = 3;
            return { value: "IconComponent", done: null };
          }
        } catch (tmp17) {
          c2 = 3;
          throw tmp17;
        }
      }
    })();
  },
  setVideoEnabled(enabled) {
    const tmp = enabled;
    if (tmp) {
      obj = applyBackgroundOption;
      const result = obj.applyInitialVideoBackgroundOption();
    }
    const obj2 = DispatcherDefault;
    const obj3 = { type: "MEDIA_ENGINE_SET_VIDEO_ENABLED", enabled };
    obj2.dispatch(obj3);
  },
  setGoLiveSource(qualityOptions) {
    qualityOptions = undefined;
    if (qualityOptions != null) {
      qualityOptions = qualityOptions.qualityOptions;
    }
    if (null != qualityOptions) {
      const preset = qualityOptions.qualityOptions.preset;
      const resolution = qualityOptions.qualityOptions.resolution;
      const frameRate = qualityOptions.qualityOptions.frameRate;
      const desktopSettings = qualityOptions.desktopSettings;
      let sound;
      const trackStreamSettingsUpdate = StreamQualityUtils.trackStreamSettingsUpdate;
      if (desktopSettings != null) {
        sound = desktopSettings.sound;
      }
      const result = trackStreamSettingsUpdate(preset, resolution, frameRate, sound);
    }
    obj = DispatcherDefault;
    const obj2 = { type: "MEDIA_ENGINE_SET_GO_LIVE_SOURCE", settings: qualityOptions };
    obj.dispatch(obj2);
  },
  setAecDump(enabled) {
    if (typeof isNotSupported === "function") {
      const tmp4 = trackVoiceAndVideoSettingsUpdateDefault;
      tmp4("diagnostic_audio_recording_enabled", enabled, MediaEngineStore.getAecDump());
      const obj2 = { type: "MEDIA_ENGINE_SET_AEC_DUMP", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  interact() {
    if (typeof isNotSupported === "function") {
      obj = DispatcherDefault;
      obj.dispatch({ type: "MEDIA_ENGINE_INTERACTION_REQUIRED", required: false });
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setEnableHardwareMuteNotice(enabled) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "MEDIA_ENGINE_SET_ENABLE_HARDWARE_MUTE_NOTICE", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setKrispSuppressionLevel(level) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_KRISP_SUPPRESSION_LEVEL", level };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setKrispModelOverride(model) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "AUDIO_SET_KRISP_MODEL_OVERRIDE", model };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
      if (MediaEngineStore.getNoiseCancellation()) {
        const self = this;
        this.setNoiseCancellation(false);
        this.setNoiseCancellation(true);
      }
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setNoiseCancellationEnableStats(arg0) {
    if (typeof isNotSupported !== "function") {
      throw new TypeError("Trying to call a non-function");
    }
  },
  setOpenH264Enabled(enabled) {
    if (typeof isNotSupported === "function") {
      const obj2 = { type: "MEDIA_ENGINE_SET_OPENH264_ENABLED", enabled };
      obj = DispatcherDefault;
      obj.dispatch(obj2);
    } else {
      throw new TypeError("Trying to call a non-function");
    }
  },
  resetMediaEngineSettings(overrides) {
    obj = DispatcherDefault;
    const obj2 = { type: "MEDIA_ENGINE_RESET_SETTINGS", overrides };
    return obj.dispatch(obj2);
  }
};
let result = size.fileFinishedImporting("actions/AudioActionCreators.tsx");

export default obj2;