vivox-sdk-node 1.0.0

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2019 Unity Technologies.
+
+This software is subject to, and made available under, the Unity Terms of Service (see Unity Terms of Service). Your use of this software constitutes your acceptance of such terms.
+
+Unless expressly provided otherwise, the software under this license is made available strictly on an "AS IS" BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the Terms of Service for details on these and other terms and conditions.”
+
+See "Third Party Notices.md" for third-party licenses information.

package/README.md

@@ -0,0 +1,62 @@
+# Vivox SDK Node.js Addon
+
+Bu proje, Vivox SDK'sını Node.js projelerinde kullanabilmek için hazırlanmış bir C++ Addon'dur. Tüm Windows mimarilerini (x64, Win32, arm64) destekleyecek şekilde yapılandırılmıştır.
+
+## Özellikler
+- **Çoklu Mimari Desteği:** `binding.gyp` dosyası x64, Win32 ve arm64 mimarileri için doğru kütüphane ve DLL eşleştirmelerini otomatik yapar.
+- **Asenkron Olay Döngüsü:** C++ tarafında çalışan bir arka plan iş parçacığı (background thread), Vivox SDK'sından gelen mesajları toplar ve Node.js tarafına `ThreadSafeFunction` kullanarak iletir.
+- **Yüksek Performans:** N-API (Node-Addon-API) kullanılarak geliştirilmiştir.
+
+## Kurulum ve Derleme
+
+### Ön Gereksinimler
+- Node.js (v14 veya üzeri önerilir)
+- Python 3.x
+- Visual Studio 2017 veya üzeri (C++ Masaüstü Geliştirme iş yükü yüklü olmalıdır)
+
+### Adımlar
+1. `node-addon` dizinine gidin:
+   ```bash
+   cd node-addon
+   ```
+2. Bağımlılıkları yükleyin:
+   ```bash
+   npm install
+   ```
+3. Addon'u derleyin:
+   ```bash
+   npm run build
+   ```
+
+## Kullanım
+
+Yeni sürüm `EventEmitter` yapısını destekler:
+
+```javascript
+const vivox = require('./index');
+
+// Olayları dinle
+vivox.on('loginSuccess', (event) => {
+    console.log('Başarıyla giriş yapıldı');
+});
+
+vivox.on('participantAdded', (event) => {
+    console.log('Yeni katılımcı:', event.participant_uri);
+});
+
+vivox.on('message', (event) => {
+    console.log(`${event.participant_uri} dedi ki: ${event.message}`);
+});
+
+// SDK'yı başlat
+vivox.initialize();
+
+// Test verileriyle bağlan (Otomatik Connector -> Login -> Join süreci)
+vivox.connectWithTestData(require('./test_data.json'));
+```
+
+## Gelişmiş Özellikler
+- **Cihaz Listeleme:** `vivox.getCaptureDevices()` ve `vivox.getRenderDevices()` çağrıları sonrası `captureDevices` ve `renderDevices` olayları tetiklenir.
+- **Mesaj Gönderme:** `vivox.sendMessage(sessHandle, "Mesaj içeriği")`
+- **Katılımcı Kontrolü:** `vivox.setParticipantMute(sessHandle, uri, true)` ve `vivox.setParticipantVolume(sessHandle, uri, 50)`
+- **3D Ses:** `vivox.set3DPosition(acctHandle, x, y, z, channelUri)`

package/README.txt

@@ -0,0 +1,10 @@
+The recommended first steps for developers using the Vivox SDKs can be found on the Unity documentation site under “Get started” in the Vivox Core documentation: https://docs.unity.com/en-us/vivox-core.
+
+You can set up and manage Vivox through the Unity Cloud Dashboard.
+
+On the dashboard you can:
+* Create one or more application credentials for accessing Vivox services.
+* Find and download Vivox SDKs for several different client platforms, game engines, sample code, and more.
+* Links to documentation such as developer guides, SDK APIs, Vivox Access Tokens, and Server to Server API.
+* Submit support tickets.
+* Review and monitor activity dashboards for your live applications.

package/binding.gyp

@@ -0,0 +1,57 @@
+{
+  "targets": [
+    {
+      "target_name": "vivoxsdk",
+      "sources": [ "src/vivox_addon.cpp" ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "vivox_sdk/include"
+      ],
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').gyp\")"
+      ],
+      "defines": [ 
+        "NAPI_DISABLE_CPP_EXCEPTIONS",
+        "BUILD_SHARED"
+      ],
+      "conditions": [
+        ['OS=="win"', {
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "ExceptionHandling": 1
+            }
+          },
+          "conditions": [
+            ['target_arch=="x64"', {
+              "libraries": [ "<(module_root_dir)/vivox_sdk/lib/vivoxsdk.lib" ],
+              "copies": [
+                {
+                  "destination": "<(PRODUCT_DIR)",
+                  "files": [ "<(module_root_dir)/vivox_sdk/lib/vivoxsdk.dll" ]
+                }
+              ]
+            }],
+            ['target_arch=="ia32"', {
+              "libraries": [ "<(module_root_dir)/../SDK/Libraries/Release/Win32/vivoxsdk.lib" ],
+              "copies": [
+                {
+                  "destination": "<(PRODUCT_DIR)",
+                  "files": [ "<(module_root_dir)/../SDK/Libraries/Release/Win32/vivoxsdk.dll" ]
+                }
+              ]
+            }],
+            ['target_arch=="arm64"', {
+              "libraries": [ "<(module_root_dir)/../SDK/Libraries/Release/arm64/vivoxsdk.lib" ],
+              "copies": [
+                {
+                  "destination": "<(PRODUCT_DIR)",
+                  "files": [ "<(module_root_dir)/../SDK/Libraries/Release/arm64/vivoxsdk.dll" ]
+                }
+              ]
+            }]
+          ]
+        }]
+      ]
+    }
+  ]
+}

package/index.d.ts

@@ -0,0 +1,249 @@
+import { EventEmitter } from 'events';
+/**
+ * Vivox SDK Hata Kodları
+ */
+export declare enum VivoxError {
+    VX_E_SUCCESS = 0,
+    VX_E_NO_MESSAGE_AVAILABLE = -1,
+    VX_E_INVALID_XML = 1000,
+    VX_E_NO_EXIST = 1001,
+    VX_E_MAX_CONNECTOR_LIMIT_EXCEEDED = 1002,
+    VX_E_MAX_SESSION_LIMIT_EXCEEDED = 1003,
+    VX_E_FAILED = 1004,
+    VX_E_ALREADY_LOGGED_IN = 1005,
+    VX_E_INVALID_ARGUMENT = 1008,
+    VX_E_INVALID_USERNAME_OR_PASSWORD = 1009,
+    VX_E_INSUFFICIENT_PRIVILEGE = 1010,
+    VX_E_NO_SUCH_SESSION = 1011,
+    VX_E_NOT_INITIALIZED = 1012,
+    VX_E_LOGIN_FAILED = 1014,
+    VX_E_WRONG_CONNECTOR = 1016,
+    VX_E_RTP_TIMEOUT = 1058,
+    VX_E_INVALID_AUTH_TOKEN = 1082,
+    VX_E_ACCESSTOKEN_ALREADY_USED = 20120,
+    VX_E_ACCESSTOKEN_EXPIRED = 20121,
+    VX_E_ACCESSTOKEN_INVALID_SIGNATURE = 20122,
+    VX_E_ACCESSTOKEN_CLAIMS_MISMATCH = 20123,
+    VX_E_ACCESSTOKEN_MALFORMED = 20124,
+    VxErrorSuccess = 0,
+    VxErrorFailed = 1004,
+    VxErrorInvalidArgument = 1008,
+    VxErrorNotLoggedIn = 5025,
+    VxErrorTargetObjectDoesNotExist = 1001,
+    VxErrorNotInitialized = 1012,
+    VxErrorAlreadyInitialized = 1085
+}
+/**
+ * Giriş (Login) durumları
+ */
+export declare enum VivoxLoginState {
+    LoggedOut = 0,
+    LoggedIn = 1,
+    LoggingIn = 2,
+    LoggingOut = 3,
+    Resetting = 4,
+    Error = 100
+}
+/**
+ * Ağ bağlantı durumları
+ */
+export declare enum VivoxConnectionState {
+    Disconnected = 0,
+    Connected = 1,
+    Recovering = 3,
+    FailedToRecover = 4,
+    Recovered = 5
+}
+/**
+ * Katılımcının kanaldan ayrılma nedenleri
+ */
+export declare enum VivoxParticipantRemovedReason {
+    Left = 0,
+    Timeout = 1,
+    Kicked = 2,
+    Banned = 3
+}
+/**
+ * Kanal medya (ses) durumları
+ */
+export declare enum VivoxSessionMediaState {
+    Disconnected = 1,
+    Connected = 2,
+    Ringing = 3,
+    Connecting = 6,
+    Disconnecting = 7
+}
+/**
+ * Kanal metin (text) durumları
+ */
+export declare enum VivoxSessionTextState {
+    Disconnected = 0,
+    Connected = 1,
+    Connecting = 2,
+    Disconnecting = 3
+}
+/**
+ * SDK Mesaj Tipleri
+ */
+export declare enum VivoxMessageType {
+    None = 0,
+    Request = 1,
+    Response = 2,
+    Event = 3
+}
+/**
+ * SDK Log Seviyeleri
+ */
+export declare enum VivoxLogLevel {
+    None = -1,
+    Error = 0,
+    Warning = 1,
+    Info = 2,
+    Debug = 3,
+    Trace = 4,
+    All = 5
+}
+/**
+ * Vivox SDK'nın desteklediği temel bir cihaz yapısı.
+ */
+export interface VivoxDevice {
+    name: string;
+    id: string;
+}
+/**
+ * C++ tarafından gelen ham olay (raw event) formatı.
+ */
+export interface VivoxRawEvent {
+    type: VivoxMessageType;
+    resp_type?: number;
+    evt_type?: number;
+    status?: number;
+    status_string?: string;
+    participant_uri?: string;
+    message?: string;
+    session_handle?: string;
+    state?: number;
+    account_handle?: string;
+    is_current_user?: number;
+    reason?: number;
+    is_speaking?: number;
+    energy?: number;
+    connection_state?: number;
+    devices?: VivoxDevice[];
+}
+/**
+ * Giriş (Login) durumundaki değişiklikleri belirten olay.
+ */
+export interface VivoxLoginStateEvent {
+    state: VivoxLoginState;
+    handle: string;
+}
+/**
+ * Kanala yeni bir katılımcının girdiğini belirten olay.
+ */
+export interface VivoxParticipantAddedEvent {
+    participant_uri: string;
+    is_current_user: boolean;
+}
+/**
+ * Kanaldan bir katılımcının ayrıldığını belirten olay.
+ */
+export interface VivoxParticipantRemovedEvent {
+    participant_uri: string;
+    reason: VivoxParticipantRemovedReason;
+}
+/**
+ * Bir katılımcının anlık konuşma (ses) aktivitesini belirten olay.
+ */
+export interface VivoxParticipantUpdatedEvent {
+    participant_uri: string;
+    is_speaking: boolean;
+    energy: number;
+}
+/**
+ * Kanal içindeki bir yazılı mesaj olayını belirtir.
+ */
+export interface VivoxMessageEvent {
+    participant_uri: string;
+    message: string;
+    session_handle: string;
+}
+/**
+ * Standart bir SDK yanıt olayını belirtir.
+ */
+export interface VivoxResponseEvent {
+    status: number;
+    status_name: string;
+    status_string?: string;
+}
+/**
+ * Vivox sınıfı tarafından fırlatılan tüm olayların tür haritası.
+ */
+export interface VivoxEvents {
+    'raw': (event: VivoxRawEvent) => void;
+    'response': (event: VivoxRawEvent) => void;
+    'event': (event: VivoxRawEvent) => void;
+    'connectorCreated': (event: VivoxResponseEvent) => void;
+    'loginSuccess': (event: VivoxResponseEvent) => void;
+    'loginFailure': (event: VivoxResponseEvent) => void;
+    'joinSuccess': (event: VivoxResponseEvent) => void;
+    'joinFailure': (event: VivoxResponseEvent) => void;
+    'renderDevices': (devices: VivoxDevice[]) => void;
+    'captureDevices': (devices: VivoxDevice[]) => void;
+    'loginStateChange': (data: VivoxLoginStateEvent) => void;
+    'participantAdded': (event: VivoxParticipantAddedEvent) => void;
+    'participantRemoved': (event: VivoxParticipantRemovedEvent) => void;
+    'participantUpdated': (event: VivoxParticipantUpdatedEvent) => void;
+    'connectionStateChanged': (state: VivoxConnectionState) => void;
+    'message': (event: VivoxMessageEvent) => void;
+}
+export declare interface Vivox {
+    on<U extends keyof VivoxEvents>(event: U, listener: VivoxEvents[U]): this;
+    emit<U extends keyof VivoxEvents>(event: U, ...args: Parameters<VivoxEvents[U]>): boolean;
+}
+/**
+ * Vivox SDK Node.js Wrapper
+ */
+export declare class Vivox extends EventEmitter {
+    private addon;
+    private initialized;
+    constructor();
+    getVersion(): string;
+    initialize(): number;
+    private _setupInternalCallback;
+    private _handleResponse;
+    private _handleEvent;
+    connectorCreate(server: string, handle?: string): number;
+    login(connectorHandle: string, accountUri: string, token: string): number;
+    loginAnonymous(connectorHandle: string, accountUri: string, token: string): number;
+    joinChannel(accountHandle: string, channelUri: string, token: string): number;
+    sendMessage(sessionHandle: string, message: string): number;
+    getCaptureDevices(): number;
+    setCaptureDevice(deviceId: string): number;
+    getRenderDevices(): number;
+    setRenderDevice(deviceId: string): number;
+    setLocalMicVolume(volume: number): number;
+    setLocalSpeakerVolume(volume: number): number;
+    muteLocalMic(connectorHandle: string, mute: boolean): number;
+    setParticipantMute(sessionHandle: string, participantUri: string, mute: boolean): number;
+    setParticipantVolume(sessionHandle: string, participantUri: string, volume: number): number;
+    muteUser(accountHandle: string, channelUri: string, participantUri: string, mute: boolean): number;
+    kickUser(accountHandle: string, channelUri: string, participantUri: string): number;
+    injectAudio(accountHandle: string, filename: string): number;
+    stopAudioInjection(accountHandle: string): number;
+    set3DPosition(accountHandle: string, posX: number, posY: number, posZ: number, channelUri: string): number;
+    uninitialize(): void;
+}
+/**
+ * Vivox Utility Fonksiyonları
+ */
+export declare const VivoxUtils: {
+    getErrorName(statusCode: number): string;
+    getLoginStateName(state: number): string;
+    getConnectionStateName(state: number): string;
+    generateAccountUri(domain: string, userId: string, environmentDomain: string): string;
+    generateChannelUri(domain: string, channelId: string, environmentDomain: string): string;
+    generateSessionHandle(channelUri: string): string;
+};
+declare const defaultInstance: Vivox;
+export default defaultInstance;

package/index.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VivoxUtils = exports.Vivox = exports.VivoxLogLevel = exports.VivoxMessageType = exports.VivoxSessionTextState = exports.VivoxSessionMediaState = exports.VivoxParticipantRemovedReason = exports.VivoxConnectionState = exports.VivoxLoginState = exports.VivoxError = void 0;
+const events_1 = require("events");
+// C++ Eklentisini yüklüyoruz
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const vivoxsdk = require('./build/Release/vivoxsdk.node');
+/**
+ * Vivox SDK Hata Kodları
+ */
+var VivoxError;
+(function (VivoxError) {
+    VivoxError[VivoxError["VX_E_SUCCESS"] = 0] = "VX_E_SUCCESS";
+    VivoxError[VivoxError["VX_E_NO_MESSAGE_AVAILABLE"] = -1] = "VX_E_NO_MESSAGE_AVAILABLE";
+    VivoxError[VivoxError["VX_E_INVALID_XML"] = 1000] = "VX_E_INVALID_XML";
+    VivoxError[VivoxError["VX_E_NO_EXIST"] = 1001] = "VX_E_NO_EXIST";
+    VivoxError[VivoxError["VX_E_MAX_CONNECTOR_LIMIT_EXCEEDED"] = 1002] = "VX_E_MAX_CONNECTOR_LIMIT_EXCEEDED";
+    VivoxError[VivoxError["VX_E_MAX_SESSION_LIMIT_EXCEEDED"] = 1003] = "VX_E_MAX_SESSION_LIMIT_EXCEEDED";
+    VivoxError[VivoxError["VX_E_FAILED"] = 1004] = "VX_E_FAILED";
+    VivoxError[VivoxError["VX_E_ALREADY_LOGGED_IN"] = 1005] = "VX_E_ALREADY_LOGGED_IN";
+    VivoxError[VivoxError["VX_E_INVALID_ARGUMENT"] = 1008] = "VX_E_INVALID_ARGUMENT";
+    VivoxError[VivoxError["VX_E_INVALID_USERNAME_OR_PASSWORD"] = 1009] = "VX_E_INVALID_USERNAME_OR_PASSWORD";
+    VivoxError[VivoxError["VX_E_INSUFFICIENT_PRIVILEGE"] = 1010] = "VX_E_INSUFFICIENT_PRIVILEGE";
+    VivoxError[VivoxError["VX_E_NO_SUCH_SESSION"] = 1011] = "VX_E_NO_SUCH_SESSION";
+    VivoxError[VivoxError["VX_E_NOT_INITIALIZED"] = 1012] = "VX_E_NOT_INITIALIZED";
+    VivoxError[VivoxError["VX_E_LOGIN_FAILED"] = 1014] = "VX_E_LOGIN_FAILED";
+    VivoxError[VivoxError["VX_E_WRONG_CONNECTOR"] = 1016] = "VX_E_WRONG_CONNECTOR";
+    VivoxError[VivoxError["VX_E_RTP_TIMEOUT"] = 1058] = "VX_E_RTP_TIMEOUT";
+    VivoxError[VivoxError["VX_E_INVALID_AUTH_TOKEN"] = 1082] = "VX_E_INVALID_AUTH_TOKEN";
+    VivoxError[VivoxError["VX_E_ACCESSTOKEN_ALREADY_USED"] = 20120] = "VX_E_ACCESSTOKEN_ALREADY_USED";
+    VivoxError[VivoxError["VX_E_ACCESSTOKEN_EXPIRED"] = 20121] = "VX_E_ACCESSTOKEN_EXPIRED";
+    VivoxError[VivoxError["VX_E_ACCESSTOKEN_INVALID_SIGNATURE"] = 20122] = "VX_E_ACCESSTOKEN_INVALID_SIGNATURE";
+    VivoxError[VivoxError["VX_E_ACCESSTOKEN_CLAIMS_MISMATCH"] = 20123] = "VX_E_ACCESSTOKEN_CLAIMS_MISMATCH";
+    VivoxError[VivoxError["VX_E_ACCESSTOKEN_MALFORMED"] = 20124] = "VX_E_ACCESSTOKEN_MALFORMED";
+    // V5 Aliasları
+    VivoxError[VivoxError["VxErrorSuccess"] = 0] = "VxErrorSuccess";
+    VivoxError[VivoxError["VxErrorFailed"] = 1004] = "VxErrorFailed";
+    VivoxError[VivoxError["VxErrorInvalidArgument"] = 1008] = "VxErrorInvalidArgument";
+    VivoxError[VivoxError["VxErrorNotLoggedIn"] = 5025] = "VxErrorNotLoggedIn";
+    VivoxError[VivoxError["VxErrorTargetObjectDoesNotExist"] = 1001] = "VxErrorTargetObjectDoesNotExist";
+    VivoxError[VivoxError["VxErrorNotInitialized"] = 1012] = "VxErrorNotInitialized";
+    VivoxError[VivoxError["VxErrorAlreadyInitialized"] = 1085] = "VxErrorAlreadyInitialized";
+})(VivoxError || (exports.VivoxError = VivoxError = {}));
+/**
+ * Giriş (Login) durumları
+ */
+var VivoxLoginState;
+(function (VivoxLoginState) {
+    VivoxLoginState[VivoxLoginState["LoggedOut"] = 0] = "LoggedOut";
+    VivoxLoginState[VivoxLoginState["LoggedIn"] = 1] = "LoggedIn";
+    VivoxLoginState[VivoxLoginState["LoggingIn"] = 2] = "LoggingIn";
+    VivoxLoginState[VivoxLoginState["LoggingOut"] = 3] = "LoggingOut";
+    VivoxLoginState[VivoxLoginState["Resetting"] = 4] = "Resetting";
+    VivoxLoginState[VivoxLoginState["Error"] = 100] = "Error";
+})(VivoxLoginState || (exports.VivoxLoginState = VivoxLoginState = {}));
+/**
+ * Ağ bağlantı durumları
+ */
+var VivoxConnectionState;
+(function (VivoxConnectionState) {
+    VivoxConnectionState[VivoxConnectionState["Disconnected"] = 0] = "Disconnected";
+    VivoxConnectionState[VivoxConnectionState["Connected"] = 1] = "Connected";
+    VivoxConnectionState[VivoxConnectionState["Recovering"] = 3] = "Recovering";
+    VivoxConnectionState[VivoxConnectionState["FailedToRecover"] = 4] = "FailedToRecover";
+    VivoxConnectionState[VivoxConnectionState["Recovered"] = 5] = "Recovered";
+})(VivoxConnectionState || (exports.VivoxConnectionState = VivoxConnectionState = {}));
+/**
+ * Katılımcının kanaldan ayrılma nedenleri
+ */
+var VivoxParticipantRemovedReason;
+(function (VivoxParticipantRemovedReason) {
+    VivoxParticipantRemovedReason[VivoxParticipantRemovedReason["Left"] = 0] = "Left";
+    VivoxParticipantRemovedReason[VivoxParticipantRemovedReason["Timeout"] = 1] = "Timeout";
+    VivoxParticipantRemovedReason[VivoxParticipantRemovedReason["Kicked"] = 2] = "Kicked";
+    VivoxParticipantRemovedReason[VivoxParticipantRemovedReason["Banned"] = 3] = "Banned";
+})(VivoxParticipantRemovedReason || (exports.VivoxParticipantRemovedReason = VivoxParticipantRemovedReason = {}));
+/**
+ * Kanal medya (ses) durumları
+ */
+var VivoxSessionMediaState;
+(function (VivoxSessionMediaState) {
+    VivoxSessionMediaState[VivoxSessionMediaState["Disconnected"] = 1] = "Disconnected";
+    VivoxSessionMediaState[VivoxSessionMediaState["Connected"] = 2] = "Connected";
+    VivoxSessionMediaState[VivoxSessionMediaState["Ringing"] = 3] = "Ringing";
+    VivoxSessionMediaState[VivoxSessionMediaState["Connecting"] = 6] = "Connecting";
+    VivoxSessionMediaState[VivoxSessionMediaState["Disconnecting"] = 7] = "Disconnecting";
+})(VivoxSessionMediaState || (exports.VivoxSessionMediaState = VivoxSessionMediaState = {}));
+/**
+ * Kanal metin (text) durumları
+ */
+var VivoxSessionTextState;
+(function (VivoxSessionTextState) {
+    VivoxSessionTextState[VivoxSessionTextState["Disconnected"] = 0] = "Disconnected";
+    VivoxSessionTextState[VivoxSessionTextState["Connected"] = 1] = "Connected";
+    VivoxSessionTextState[VivoxSessionTextState["Connecting"] = 2] = "Connecting";
+    VivoxSessionTextState[VivoxSessionTextState["Disconnecting"] = 3] = "Disconnecting";
+})(VivoxSessionTextState || (exports.VivoxSessionTextState = VivoxSessionTextState = {}));
+/**
+ * SDK Mesaj Tipleri
+ */
+var VivoxMessageType;
+(function (VivoxMessageType) {
+    VivoxMessageType[VivoxMessageType["None"] = 0] = "None";
+    VivoxMessageType[VivoxMessageType["Request"] = 1] = "Request";
+    VivoxMessageType[VivoxMessageType["Response"] = 2] = "Response";
+    VivoxMessageType[VivoxMessageType["Event"] = 3] = "Event";
+})(VivoxMessageType || (exports.VivoxMessageType = VivoxMessageType = {}));
+/**
+ * SDK Log Seviyeleri
+ */
+var VivoxLogLevel;
+(function (VivoxLogLevel) {
+    VivoxLogLevel[VivoxLogLevel["None"] = -1] = "None";
+    VivoxLogLevel[VivoxLogLevel["Error"] = 0] = "Error";
+    VivoxLogLevel[VivoxLogLevel["Warning"] = 1] = "Warning";
+    VivoxLogLevel[VivoxLogLevel["Info"] = 2] = "Info";
+    VivoxLogLevel[VivoxLogLevel["Debug"] = 3] = "Debug";
+    VivoxLogLevel[VivoxLogLevel["Trace"] = 4] = "Trace";
+    VivoxLogLevel[VivoxLogLevel["All"] = 5] = "All";
+})(VivoxLogLevel || (exports.VivoxLogLevel = VivoxLogLevel = {}));
+/**
+ * Vivox SDK Node.js Wrapper
+ */
+class Vivox extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.addon = vivoxsdk;
+        this.initialized = false;
+    }
+    getVersion() {
+        return this.addon.getVersion();
+    }
+    initialize() {
+        const status = this.addon.initialize();
+        if (status === 0 && !this.initialized) {
+            this.initialized = true;
+            this._setupInternalCallback();
+        }
+        return status;
+    }
+    _setupInternalCallback() {
+        this.addon.setEventCallback((event) => {
+            this.emit('raw', event);
+            if (event.type === VivoxMessageType.Response)
+                this._handleResponse(event);
+            else if (event.type === VivoxMessageType.Event)
+                this._handleEvent(event);
+        });
+    }
+    _handleResponse(event) {
+        const status = event.status ?? -1;
+        const payload = {
+            status,
+            status_name: exports.VivoxUtils.getErrorName(status),
+            status_string: event.status_string
+        };
+        switch (event.resp_type) {
+            case 1:
+                this.emit('connectorCreated', payload);
+                break;
+            case 131:
+            case 132:
+                if (status === 0)
+                    this.emit('loginSuccess', payload);
+                else
+                    this.emit('loginFailure', payload);
+                break;
+            case 8:
+                if (status === 0)
+                    this.emit('joinSuccess', payload);
+                else
+                    this.emit('joinFailure', payload);
+                break;
+            case 87:
+                this.emit('renderDevices', event.devices || []);
+                break;
+            case 88:
+                this.emit('captureDevices', event.devices || []);
+                break;
+            default: this.emit('response', event);
+        }
+    }
+    _handleEvent(event) {
+        switch (event.evt_type) {
+            case 2:
+                this.emit('loginStateChange', { state: event.state ?? 0, handle: event.account_handle ?? '' });
+                break;
+            case 26:
+                this.emit('participantAdded', { participant_uri: event.participant_uri ?? '', is_current_user: event.is_current_user === 1 });
+                break;
+            case 27:
+                this.emit('participantRemoved', { participant_uri: event.participant_uri ?? '', reason: event.reason ?? 0 });
+                break;
+            case 28:
+                this.emit('participantUpdated', { participant_uri: event.participant_uri ?? '', is_speaking: event.is_speaking === 1, energy: event.energy ?? 0 });
+                break;
+            case 53:
+                this.emit('connectionStateChanged', event.connection_state ?? 0);
+                break;
+            case 10:
+                this.emit('message', { participant_uri: event.participant_uri ?? '', message: event.message ?? '', session_handle: event.session_handle ?? '' });
+                break;
+            default: this.emit('event', event);
+        }
+    }
+    // --- SDK Methods ---
+    connectorCreate(server, handle = "default") { return this.addon.connectorCreate(server, handle); }
+    login(connectorHandle, accountUri, token) { return this.addon.login(connectorHandle, accountUri, token); }
+    loginAnonymous(connectorHandle, accountUri, token) { return this.addon.loginAnonymous(connectorHandle, accountUri, token); }
+    joinChannel(accountHandle, channelUri, token) { return this.addon.joinChannel(accountHandle, channelUri, token); }
+    sendMessage(sessionHandle, message) { return this.addon.sendMessage(sessionHandle, message); }
+    getCaptureDevices() { return this.addon.getCaptureDevices(); }
+    setCaptureDevice(deviceId) { return this.addon.setCaptureDevice(deviceId); }
+    getRenderDevices() { return this.addon.getRenderDevices(); }
+    setRenderDevice(deviceId) { return this.addon.setRenderDevice(deviceId); }
+    setLocalMicVolume(volume) { return this.addon.setLocalMicVolume(volume); }
+    setLocalSpeakerVolume(volume) { return this.addon.setLocalSpeakerVolume(volume); }
+    muteLocalMic(connectorHandle, mute) { return this.addon.muteLocalMic(connectorHandle, mute ? 1 : 0); }
+    setParticipantMute(sessionHandle, participantUri, mute) { return this.addon.setParticipantMuteForMe(sessionHandle, participantUri, mute ? 1 : 0); }
+    setParticipantVolume(sessionHandle, participantUri, volume) { return this.addon.setParticipantVolumeForMe(sessionHandle, participantUri, volume); }
+    muteUser(accountHandle, channelUri, participantUri, mute) { return this.addon.channelMuteUser(accountHandle, channelUri, participantUri, mute ? 1 : 0); }
+    kickUser(accountHandle, channelUri, participantUri) { return this.addon.kickUser(accountHandle, channelUri, participantUri); }
+    injectAudio(accountHandle, filename) { return this.addon.startAudioInjection(accountHandle, filename); }
+    stopAudioInjection(accountHandle) { return this.addon.stopAudioInjection(accountHandle); }
+    set3DPosition(accountHandle, posX, posY, posZ, channelUri) {
+        const sessionHandle = `${channelUri}_sess`;
+        return this.addon.set3DPosition(accountHandle, posX, posY, posZ, sessionHandle);
+    }
+    uninitialize() { this.initialized = false; this.addon.uninitialize(); }
+}
+exports.Vivox = Vivox;
+/**
+ * Vivox Utility Fonksiyonları
+ */
+exports.VivoxUtils = {
+    getErrorName(statusCode) {
+        for (const [key, value] of Object.entries(VivoxError)) {
+            if (value === statusCode)
+                return key;
+        }
+        return `UNKNOWN_ERROR_${statusCode}`;
+    },
+    getLoginStateName(state) {
+        for (const [key, value] of Object.entries(VivoxLoginState)) {
+            if (value === state)
+                return key;
+        }
+        return `UNKNOWN_STATE_${state}`;
+    },
+    getConnectionStateName(state) {
+        for (const [key, value] of Object.entries(VivoxConnectionState)) {
+            if (value === state)
+                return key;
+        }
+        return `UNKNOWN_CONNECTION_STATE_${state}`;
+    },
+    generateAccountUri(domain, userId, environmentDomain) {
+        return `sip:.${domain}.${userId}.@${environmentDomain}`;
+    },
+    generateChannelUri(domain, channelId, environmentDomain) {
+        return `sip:confctl-g-${domain}.${channelId}@${environmentDomain}`;
+    },
+    generateSessionHandle(channelUri) {
+        return `${channelUri}_sess`;
+    }
+};
+const defaultInstance = new Vivox();
+exports.default = defaultInstance;
+module.exports = defaultInstance;
+module.exports.Vivox = Vivox;
+module.exports.VivoxUtils = exports.VivoxUtils;
+module.exports.VivoxError = VivoxError;
+module.exports.VivoxLoginState = VivoxLoginState;
+module.exports.VivoxConnectionState = VivoxConnectionState;
+module.exports.VivoxParticipantRemovedReason = VivoxParticipantRemovedReason;
+module.exports.VivoxSessionMediaState = VivoxSessionMediaState;
+module.exports.VivoxSessionTextState = VivoxSessionTextState;
+module.exports.VivoxMessageType = VivoxMessageType;
+module.exports.VivoxLogLevel = VivoxLogLevel;