steelseries-sonar-sdk 0.2.0 → 0.2.2

package/dist/index.js

@@ -0,0 +1,874 @@
+// src/enums.ts
+var AudioChannel;
+((AudioChannel2) => {
+  AudioChannel2["Master"] = "master";
+  AudioChannel2["Game"] = "game";
+  AudioChannel2["Chat"] = "chat";
+  AudioChannel2["Media"] = "media";
+  AudioChannel2["Aux"] = "aux";
+  AudioChannel2["Mic"] = "mic";
+})(AudioChannel ||= {});
+var ProfileChannel;
+((ProfileChannel2) => {
+  ProfileChannel2["Game"] = "game";
+  ProfileChannel2["Chat"] = "chat";
+  ProfileChannel2["Media"] = "media";
+  ProfileChannel2["Aux"] = "aux";
+  ProfileChannel2["Mic"] = "mic";
+})(ProfileChannel ||= {});
+var DeviceChannel;
+((DeviceChannel2) => {
+  DeviceChannel2["Output"] = "render";
+  DeviceChannel2["Game"] = "game";
+  DeviceChannel2["Chat"] = "chat";
+  DeviceChannel2["Media"] = "media";
+  DeviceChannel2["Aux"] = "aux";
+  DeviceChannel2["Mic"] = "mic";
+})(DeviceChannel ||= {});
+var StreamerPath;
+((StreamerPath2) => {
+  StreamerPath2["Streaming"] = "streaming";
+  StreamerPath2["Monitoring"] = "monitoring";
+})(StreamerPath ||= {});
+var AudioMode;
+((AudioMode2) => {
+  AudioMode2["Classic"] = "classic";
+  AudioMode2["Streamer"] = "stream";
+})(AudioMode ||= {});
+var ChatMixState;
+((ChatMixState2) => {
+  ChatMixState2["Enabled"] = "enabled";
+  ChatMixState2["FiniteWheel"] = "finiteWheel";
+  ChatMixState2["DifferentDeviceSelected"] = "differentDeviceSelected";
+  ChatMixState2["NoDeviceSelected"] = "noDeviceSelected";
+})(ChatMixState ||= {});
+var DeviceFlow;
+((DeviceFlow2) => {
+  DeviceFlow2["Output"] = "output";
+  DeviceFlow2["Input"] = "input";
+})(DeviceFlow ||= {});
+// src/exceptions.ts
+var InitializeErrorReason;
+((InitializeErrorReason2) => {
+  InitializeErrorReason2["BadConfig"] = "Bad Config";
+  InitializeErrorReason2["OSUnsupported"] = "OS Unsupported";
+  InitializeErrorReason2["NotEnabled"] = "Not Enabled";
+  InitializeErrorReason2["NotRunning"] = "Not Running";
+  InitializeErrorReason2["NotReady"] = "Not Ready";
+  InitializeErrorReason2["NotResponding"] = "Not Responding";
+  InitializeErrorReason2["NotAvailable"] = "Not Available";
+})(InitializeErrorReason ||= {});
+
+class SonarException extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    super.name = new.target.name;
+  }
+}
+
+class SonarRequestException extends SonarException {
+  constructor(error) {
+    super(error?.message ?? "There was an issue communicating with the Sonar service.", error?.innerException);
+  }
+}
+
+class SonarInitializationException extends SonarException {
+  reason;
+  constructor(error) {
+    const message = `${error?.message ?? `There was an issue finding the Sonar service: ${error.reason}.`}${error?.innerException ? " See inner exception." : ""}`;
+    super(message, error?.innerException);
+    this.reason = error.reason;
+  }
+}
+// src/functions/converters/convert-volume-to-user.ts
+function convertVolumeToUser(value) {
+  let result = value * 100;
+  result = Math.min(Math.max(result, 0), 100);
+  result = Math.floor(result);
+  return result;
+}
+
+// src/sonar/requests/volume-settings/request-volume-settings-classic.ts
+async function requestVolumeSettingsClassic(sonarEndpoint) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/classic`);
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.classic == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/audio/get-audio-data-classic.ts
+async function getAudioDataClassic(sonarEndpoint) {
+  const data = await requestVolumeSettingsClassic(sonarEndpoint);
+  const volumeData = {
+    ["master" /* Master */]: createResponseVolumeData(data.masters.classic),
+    ["game" /* Game */]: data.devices.game && createResponseVolumeData(data.devices.game.classic),
+    ["chat" /* Chat */]: data.devices.chatRender && createResponseVolumeData(data.devices.chatRender.classic),
+    ["media" /* Media */]: data.devices.media && createResponseVolumeData(data.devices.media.classic),
+    ["aux" /* Aux */]: data.devices.aux && createResponseVolumeData(data.devices.aux.classic),
+    ["mic" /* Mic */]: data.devices.chatCapture && createResponseVolumeData(data.devices.chatCapture.classic)
+  };
+  return volumeData;
+}
+function createResponseVolumeData(volumeData) {
+  return {
+    volume: convertVolumeToUser(volumeData.volume),
+    isMuted: volumeData.muted
+  };
+}
+// src/sonar/requests/volume-settings/request-volume-settings-streamer.ts
+async function requestVolumeSettingsStreamer(sonarEndpoint) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer`);
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.stream == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/audio/get-audio-data-stream.ts
+async function getAudioDataStream(sonarEndpoint) {
+  const data = await requestVolumeSettingsStreamer(sonarEndpoint);
+  const volumeData = {
+    ["master" /* Master */]: createResponseVolumeData2(data.masters.stream),
+    ["game" /* Game */]: data.devices.game && createResponseVolumeData2(data.devices.game.stream),
+    ["chat" /* Chat */]: data.devices.chatRender && createResponseVolumeData2(data.devices.chatRender.stream),
+    ["media" /* Media */]: data.devices.media && createResponseVolumeData2(data.devices.media.stream),
+    ["aux" /* Aux */]: data.devices.aux && createResponseVolumeData2(data.devices.aux.stream),
+    ["mic" /* Mic */]: data.devices.chatCapture && createResponseVolumeData2(data.devices.chatCapture.stream)
+  };
+  return volumeData;
+}
+function createResponseVolumeData2(volumeData) {
+  return {
+    ["streaming" /* Streaming */]: {
+      volume: convertVolumeToUser(volumeData.streaming.volume),
+      isMuted: volumeData.streaming.muted
+    },
+    ["monitoring" /* Monitoring */]: {
+      volume: convertVolumeToUser(volumeData.monitoring.volume),
+      isMuted: volumeData.monitoring.muted
+    }
+  };
+}
+// src/sonar/models/audio-settings/enums/audio-mode.ts
+var AudioMode2;
+((AudioMode3) => {
+  AudioMode3["Classic"] = "classic";
+  AudioMode3["Streamer"] = "stream";
+})(AudioMode2 ||= {});
+
+// src/sonar/requests/mode/request-audio-mode.ts
+async function requestAudioMode(sonarEndpoint) {
+  let response;
+  const url = new URL(`${sonarEndpoint}/mode`);
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (Object.values(AudioMode2).includes(data)) {
+      return data;
+    }
+    throw new SonarRequestException({ message: "Received unhandled audio mode from Sonar server" });
+  } else {
+    const data = await response.text();
+    throw new SonarRequestException({ innerException: new Error(data) });
+  }
+}
+
+// src/functions/audio/get-audio-mode.ts
+async function getAudioMode(sonarEndpoint) {
+  return await requestAudioMode(sonarEndpoint);
+}
+// src/sonar/requests/mode/change-audio-mode.ts
+async function changeAudioMode(sonarEndpoint, audioMode) {
+  let response;
+  const url = new URL(`${sonarEndpoint}/mode/${audioMode}`);
+  try {
+    response = await fetch(url, {
+      method: "PUT"
+    });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data !== audioMode) {
+      throw new SonarRequestException({ message: "Returned audio mode does not match requested mode" });
+    }
+    return data;
+  } else {
+    const data = await response.text();
+    throw new SonarRequestException({ innerException: new Error(data) });
+  }
+}
+
+// src/functions/audio/set-audio-mode.ts
+async function setAudioMode(sonarEndpoint, audioMode) {
+  return await changeAudioMode(sonarEndpoint, audioMode);
+}
+// src/functions/converters/convert-channel-to-api.ts
+function convertChannelToApi(channel) {
+  switch (channel) {
+    case "master" /* Master */:
+      return "master" /* Master */;
+    case "game" /* Game */:
+      return "chatRender" /* ChatRender */;
+    case "media" /* Media */:
+      return "media" /* Media */;
+    case "aux" /* Aux */:
+      return "aux" /* Aux */;
+    case "mic" /* Mic */:
+      return "chatCapture" /* ChatCapture */;
+    default:
+      throw new Error(`Unsupported AudioChannel: ${channel}`);
+  }
+}
+
+// src/sonar/requests/volume-settings/change-volume-mute-classic.ts
+async function changeVolumeMuteClassic(sonarEndpoint, isMuted, deviceRole) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/classic/${deviceRole}/mute/${isMuted}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.classic == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/audio/set-channel-mute-classic.ts
+async function setChannelMuteClassic(sonarEndpoint, isMuted, channel) {
+  const sonarChannel = convertChannelToApi(channel);
+  const data = await changeVolumeMuteClassic(sonarEndpoint, isMuted, sonarChannel);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.classic : data.devices[sonarChannel]?.classic;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
+  }
+  const result = {
+    volume: convertVolumeToUser(device.volume),
+    isMuted: device.muted
+  };
+  return result;
+}
+// src/sonar/requests/volume-settings/change-volume-mute-streamer.ts
+async function changeVolumeMuteStreamer(sonarEndpoint, isMuted, deviceRole, path) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer/${path}/${deviceRole}/isMuted/${isMuted}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.stream == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/audio/set-channel-mute-streamer.ts
+async function setChannelMuteStreamer(sonarEndpoint, isMuted, channel, path) {
+  const sonarChannel = convertChannelToApi(channel);
+  const streamPath = path === "streaming" /* Streaming */ ? "streaming" /* Streaming */ : "monitoring" /* Monitoring */;
+  const data = await changeVolumeMuteStreamer(sonarEndpoint, isMuted, sonarChannel, streamPath);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.stream : data.devices[sonarChannel]?.stream;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
+  }
+  const devicePath = path === "streaming" /* Streaming */ ? device.streaming : device.monitoring;
+  const result = {
+    volume: convertVolumeToUser(devicePath.volume),
+    isMuted: devicePath.muted
+  };
+  return result;
+}
+// src/functions/converters/convert-volume-to-api.ts
+function convertVolumeToApi(value) {
+  let result = value / 100;
+  result = Math.min(Math.max(result, 0), 1);
+  return result;
+}
+
+// src/sonar/requests/volume-settings/change-volume-level-classic.ts
+async function changeVolumeLevelClassic(sonarEndpoint, volume, deviceRole) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/classic/${deviceRole}/volume/${volume}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.classic == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/audio/set-channel-volume-classic.ts
+async function setChannelVolumeClassic(sonarEndpoint, volumePercent, channel) {
+  const sonarChannel = convertChannelToApi(channel);
+  const formattedVolume = convertVolumeToApi(volumePercent);
+  const data = await changeVolumeLevelClassic(sonarEndpoint, formattedVolume, sonarChannel);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.classic : data.devices[sonarChannel]?.classic;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
+  }
+  const result = {
+    volume: convertVolumeToUser(device.volume),
+    isMuted: device.muted
+  };
+  return result;
+}
+// src/sonar/requests/volume-settings/change-volume-level-streamer.ts
+async function changeVolumeLevelStreamer(sonarEndpoint, volume, channel, path) {
+  let response;
+  try {
+    const url = new URL(`${sonarEndpoint}/volumeSettings/streamer/${path}/${channel}/volume/${volume}`);
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.masters?.stream == null) {
+      throw new SonarRequestException({ innerException: new Error("Missing required data in response.") });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/audio/set-channel-volume-streamer.ts
+async function setChannelVolumeStreamer(sonarEndpoint, volumePercent, channel, path) {
+  const sonarChannel = convertChannelToApi(channel);
+  const formattedVolume = convertVolumeToApi(volumePercent);
+  const streamPath = path === "streaming" /* Streaming */ ? "streaming" /* Streaming */ : "monitoring" /* Monitoring */;
+  const data = await changeVolumeLevelStreamer(sonarEndpoint, formattedVolume, sonarChannel, streamPath);
+  const device = sonarChannel === "master" /* Master */ ? data.masters.stream : data.devices[sonarChannel]?.stream;
+  if (!device) {
+    throw new SonarRequestException({ message: `Missing device data in response.` });
+  }
+  const devicePath = path === "streaming" /* Streaming */ ? device.streaming : device.monitoring;
+  const result = {
+    volume: convertVolumeToUser(devicePath.volume),
+    isMuted: devicePath.muted
+  };
+  return result;
+}
+// src/functions/converters/convert-chat-mix-balance-to-user.ts
+function convertChatMixBalanceToUser(balance) {
+  let result = (balance + 1) / 2 * 100;
+  result = Math.floor(result);
+  result = Math.min(Math.max(result, 0), 100);
+  return result;
+}
+
+// src/sonar/requests/chatmix/request-chat-mix-state.ts
+async function requestChatMixState(sonarEndpoint) {
+  const url = new URL(`${sonarEndpoint}/chatMix`);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.balance == null || data?.state == null) {
+      throw new SonarRequestException({ message: "Missing required data in response" });
+    }
+    return data;
+  } else {
+    const data = await response.text();
+    throw new SonarRequestException({ innerException: new Error(data) });
+  }
+}
+
+// src/functions/chatmix/get-chat-mix-state.ts
+async function getChatMixState(sonarEndpoint) {
+  const data = await requestChatMixState(sonarEndpoint);
+  const chatMixData = {
+    chatBalance: convertChatMixBalanceToUser(data.balance),
+    state: data.state,
+    isEnabled: data.state === "enabled" /* Enabled */
+  };
+  return chatMixData;
+}
+// src/functions/converters/convert-chat-mix-balance-to-api.ts
+function convertChatMixBalanceToApi(balance) {
+  let result = balance / 100 * 2 - 1;
+  result = Math.min(Math.max(result, -1), 1);
+  return result;
+}
+
+// src/sonar/requests/chatmix/change-chat-mix-balance.ts
+async function changeChatMixBalance(sonarEndpoint, chatBalance) {
+  const url = new URL(`${sonarEndpoint}/chatMix?balance=${chatBalance}`);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "PUT"
+    });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (data?.balance == null || data?.state == null) {
+      throw new SonarRequestException({ message: "Missing required data in response" });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ message: data.Message });
+  }
+}
+
+// src/functions/chatmix/set-chat-mix-balance.ts
+async function setChatMixBalance(sonarEndpoint, chatBalance) {
+  const balance = convertChatMixBalanceToApi(chatBalance);
+  const data = await changeChatMixBalance(sonarEndpoint, balance);
+  const chatMixData = {
+    chatBalance: convertChatMixBalanceToUser(data.balance),
+    state: data.state,
+    isEnabled: data.state === "enabled" /* Enabled */
+  };
+  return chatMixData;
+}
+// src/sonar/requests/audio-devices/request-audio-devices.ts
+async function requestAudioDevices(sonarEndpoint, params) {
+  const { deviceDataFlow, onlySteelSeriesVAD = false, removeSteelSeriesVAD = false } = params;
+  const url = new URL(`${sonarEndpoint}/audioDevices`);
+  url.searchParams.append("onlySteelSeriesVAD", String(onlySteelSeriesVAD));
+  url.searchParams.append("removeSteelSeriesVAD", String(removeSteelSeriesVAD));
+  if (deviceDataFlow !== undefined) {
+    url.searchParams.append("deviceDataFlow", deviceDataFlow.toString());
+  }
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new SonarRequestException({
+      innerException: error
+    });
+  }
+  if (!response.ok) {
+    const error = await response.text();
+    throw new SonarRequestException({ message: `Failed to get audio devices: ${error}` });
+  }
+  const data = await response.json();
+  if (!Array.isArray(data)) {
+    throw new SonarRequestException({ message: "Invalid audio devices response format." });
+  }
+  return data;
+}
+
+// src/functions/devices/get-audio-devices.ts
+async function getAudioDevices(sonarEndpoint, deviceType) {
+  let deviceDataFlow;
+  switch (deviceType) {
+    case "input" /* Input */:
+      deviceDataFlow = "capture" /* Capture */;
+      break;
+    case "output" /* Output */:
+      deviceDataFlow = "render" /* Render */;
+      break;
+    case undefined:
+      deviceDataFlow = "all" /* All */;
+      break;
+  }
+  const data = await requestAudioDevices(sonarEndpoint, { deviceDataFlow, removeSteelSeriesVAD: true });
+  const audioDevices = data.map((device) => ({
+    id: device.id,
+    name: device.friendlyName,
+    type: getDeviceTypeFromDataFlow(device.dataFlow)
+  }));
+  return audioDevices;
+}
+function getDeviceTypeFromDataFlow(dataFlow) {
+  switch (dataFlow) {
+    case "capture" /* Capture */:
+      return "input" /* Input */;
+    case "render" /* Render */:
+      return "output" /* Output */;
+    default:
+      throw new SonarRequestException({ message: `Unknown device data flow: ${dataFlow}` });
+  }
+}
+// src/sonar/requests/audio-devices/change-audio-device.ts
+async function changeAudioDevice(sonarEndpoint, deviceChannel, deviceId) {
+  let response;
+  const url = new URL(`${sonarEndpoint}/classicRedirections/${deviceChannel}/deviceId/${deviceId}`);
+  try {
+    response = await fetch(url, { method: "PUT" });
+  } catch (error) {
+    throw new SonarRequestException({
+      innerException: error
+    });
+  }
+  if (!response.ok) {
+    const error = await response.text();
+    throw new SonarRequestException({ message: `Failed to get audio devices: ${error}` });
+  }
+  const unknownData = await response.json();
+  const data = Array.isArray(unknownData) ? unknownData : [unknownData];
+  const devices = data.filter((x) => x?.deviceId === deviceId);
+  if (devices.length === 0) {
+    throw new SonarRequestException({ message: "The changed audio devices list is empty." });
+  }
+  return devices;
+}
+
+// src/functions/devices/set-audio-device.ts
+async function setAudioDevice(sonarEndpoint, deviceChannel, deviceId) {
+  const data = await changeAudioDevice(sonarEndpoint, deviceChannel, deviceId);
+  const result = data.map((x) => ({
+    deviceId: x.deviceId,
+    deviceChannel: x.id,
+    isRunning: x.isRunning
+  }));
+  return result;
+}
+// src/functions/endpoint/get-app-endpoint.ts
+import { promises as fsAsync } from "node:fs";
+import { platform as getPlatform } from "node:os";
+import { join as joinPath } from "node:path";
+var WINDOWS_PATHS = ["SteelSeries", "SteelSeries Engine 3", "coreProps.json"];
+async function getAppEndpoint() {
+  const appDataPath = getPath();
+  const fileContents = await getContents(appDataPath);
+  const data = parseContents(fileContents);
+  if (data.ggEncryptedAddress) {
+    return `https://${data.ggEncryptedAddress}`;
+  }
+  throw new SonarInitializationException({
+    reason: "Bad Config" /* BadConfig */
+  });
+}
+function getPath() {
+  const os = getPlatform();
+  switch (os) {
+    case "win32": {
+      const programData = process.env.ProgramData ?? "C:\\ProgramData";
+      return joinPath(programData, ...WINDOWS_PATHS);
+    }
+    default:
+      throw new SonarInitializationException({
+        reason: "OS Unsupported" /* OSUnsupported */
+      });
+  }
+}
+async function getContents(path) {
+  try {
+    return await fsAsync.readFile(path, "utf8");
+  } catch (error) {
+    throw new SonarInitializationException({
+      reason: "Bad Config" /* BadConfig */,
+      innerException: error
+    });
+  }
+}
+function parseContents(contents) {
+  try {
+    return JSON.parse(contents);
+  } catch (error) {
+    throw new SonarInitializationException({
+      reason: "Bad Config" /* BadConfig */,
+      innerException: error
+    });
+  }
+}
+// src/functions/endpoint/get-sonar-endpoint.ts
+async function getSonarEndpoint(appEndpoint) {
+  let response;
+  try {
+    response = await fetch(`${appEndpoint}/subApps`, {
+      tls: {
+        rejectUnauthorized: false
+      }
+    });
+  } catch (error) {
+    throw new SonarInitializationException({
+      reason: "Not Responding" /* NotResponding */,
+      innerException: error
+    });
+  }
+  if (!response.ok) {
+    throw new SonarInitializationException({
+      reason: "Not Responding" /* NotResponding */
+    });
+  }
+  const result = await response.json();
+  const sonar = result?.subApps?.sonar;
+  if (!sonar) {
+    throw new SonarInitializationException({
+      reason: "Not Available" /* NotAvailable */
+    });
+  }
+  if (!sonar.isEnabled) {
+    throw new SonarInitializationException({
+      reason: "Not Enabled" /* NotEnabled */
+    });
+  }
+  if (!sonar.isRunning) {
+    throw new SonarInitializationException({
+      reason: "Not Running" /* NotRunning */
+    });
+  }
+  if (!sonar.isReady) {
+    throw new SonarInitializationException({
+      reason: "Not Ready" /* NotReady */
+    });
+  }
+  const sonarAddress = sonar.metadata?.webServerAddress;
+  if (!sonarAddress) {
+    throw new SonarInitializationException({
+      reason: "Not Available" /* NotAvailable */
+    });
+  }
+  return sonarAddress;
+}
+// src/functions/endpoint/get-sonar-endpoint-cached.ts
+var cache = {
+  appAddress: null,
+  sonarAddress: null,
+  timestamp: 0
+};
+async function getSonarEndpointCached(appAddress, seconds = 60) {
+  const now = Date.now();
+  if (cache.appAddress === appAddress && cache.sonarAddress && now - cache.timestamp < seconds * 1000) {
+    return cache.sonarAddress;
+  }
+  try {
+    const sonarAddress = await getSonarEndpoint(appAddress);
+    cache.appAddress = appAddress;
+    cache.sonarAddress = sonarAddress;
+    cache.timestamp = now;
+    return sonarAddress;
+  } catch (error) {
+    cache.appAddress = null;
+    cache.sonarAddress = null;
+    cache.timestamp = 0;
+    throw error;
+  }
+}
+// src/functions/converters/convert-profile-channel-to-api.ts
+function convertProfileChannelToApi(channel) {
+  switch (channel) {
+    case "game" /* Game */:
+      return "game" /* Game */;
+    case "chat" /* Chat */:
+      return "chatRender" /* ChatRender */;
+    case "media" /* Media */:
+      return "media" /* Media */;
+    case "aux" /* Aux */:
+      return "aux" /* Aux */;
+    case "mic" /* Mic */:
+      return "chatCapture" /* ChatCapture */;
+    default:
+      throw new Error(`Unsupported ProfileChannel: ${channel}`);
+  }
+}
+
+// src/functions/converters/convert-profile-channel-to-user.ts
+function convertProfileChannelToUser(channel) {
+  switch (channel) {
+    case "game" /* Game */:
+      return "game" /* Game */;
+    case "chatRender" /* ChatRender */:
+      return "chat" /* Chat */;
+    case "media" /* Media */:
+      return "media" /* Media */;
+    case "aux" /* Aux */:
+      return "aux" /* Aux */;
+    case "chatCapture" /* ChatCapture */:
+      return "mic" /* Mic */;
+    default:
+      throw new Error(`Unsupported ProfileChannel: ${channel}`);
+  }
+}
+
+// src/sonar/requests/profiles/request-configs.ts
+async function requestConfigs(sonarAddress, channel) {
+  let response;
+  try {
+    response = await fetch(`${sonarAddress}/configs?vad=${channel}`);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (!Array.isArray(data)) {
+      throw new SonarRequestException({ message: "Missing required data in response" });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/profile/get-channel-profiles.ts
+async function getChannelProfiles(sonarAddress, channel, favoritesOnly) {
+  const vad = convertProfileChannelToApi(channel);
+  const data = await requestConfigs(sonarAddress, vad);
+  const workingSetData = favoritesOnly ? data.filter((x) => x.isFavorite) : data;
+  return workingSetData.map((x) => {
+    const profile = {
+      id: x.id,
+      name: x.name,
+      isFavorite: x.isFavorite,
+      channel: convertProfileChannelToUser(x.virtualAudioDevice),
+      image: x.image
+    };
+    return profile;
+  });
+}
+// src/sonar/requests/profiles/request-selected-configs.ts
+async function requestSelectedConfigs(sonarAddress) {
+  let response;
+  try {
+    response = await fetch(`${sonarAddress}/configs/selected`);
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (!Array.isArray(data)) {
+      throw new SonarRequestException({ message: "Missing required data in response" });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/profile/get-selected-profiles.ts
+async function getSelectedProfiles(sonarAddress) {
+  const data = await requestSelectedConfigs(sonarAddress);
+  return data.map((x) => {
+    const profile = {
+      id: x.id,
+      name: x.name,
+      isFavorite: x.isFavorite,
+      channel: convertProfileChannelToUser(x.virtualAudioDevice),
+      image: x.image
+    };
+    return profile;
+  });
+}
+// src/sonar/requests/profiles/change-selected-config.ts
+async function changeSelectedConfig(sonarAddress, configId) {
+  let response;
+  try {
+    response = await fetch(`${sonarAddress}/configs/${configId}/select`, {
+      method: "PUT"
+    });
+  } catch (error) {
+    throw new SonarRequestException({ innerException: error });
+  }
+  if (response.ok) {
+    const data = await response.json();
+    if (!data?.id) {
+      throw new SonarRequestException({ message: "Missing required data in response" });
+    }
+    return data;
+  } else {
+    const data = await response.json();
+    throw new SonarRequestException({ innerException: new Error(data?.error ?? data) });
+  }
+}
+
+// src/functions/profile/set-selected-profile.ts
+async function setSelectedProfile(sonarAddress, profileId) {
+  const data = await changeSelectedConfig(sonarAddress, profileId);
+  const result = {
+    id: data.id,
+    name: data.name,
+    isFavorite: data.isFavorite,
+    channel: convertProfileChannelToUser(data.virtualAudioDevice),
+    image: data.image
+  };
+  return result;
+}
+export {
+  setSelectedProfile,
+  setChatMixBalance,
+  setChannelVolumeStreamer,
+  setChannelVolumeClassic,
+  setChannelMuteStreamer,
+  setChannelMuteClassic,
+  setAudioMode,
+  setAudioDevice,
+  getSonarEndpointCached,
+  getSonarEndpoint,
+  getSelectedProfiles,
+  getChatMixState,
+  getChannelProfiles,
+  getAudioMode,
+  getAudioDevices,
+  getAudioDataStream,
+  getAudioDataClassic,
+  getAppEndpoint,
+  StreamerPath,
+  SonarRequestException,
+  SonarInitializationException,
+  SonarException,
+  ProfileChannel,
+  InitializeErrorReason,
+  DeviceFlow,
+  DeviceChannel,
+  ChatMixState,
+  AudioMode,
+  AudioChannel
+};