diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.cxx
index 259e794b6f..5fb539d0c4 100644
--- a/src/mod/languages/mod_managed/freeswitch_wrap.cxx
+++ b/src/mod/languages/mod_managed/freeswitch_wrap.cxx
@@ -6523,6 +6523,100 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_app_log(void * jarg1) {
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_func_set(void * jarg1, void * jarg2) {
+  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+  switch_thread_start_t arg2 ;
+  switch_thread_start_t *argp2 ;
+  
+  arg1 = (switch_thread_data_t *)jarg1; 
+  argp2 = (switch_thread_start_t *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_thread_start_t", 0);
+    return ;
+  }
+  arg2 = *argp2; 
+  if (arg1) (arg1)->func = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_func_get(void * jarg1) {
+  void * jresult ;
+  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+  switch_thread_start_t result;
+  
+  arg1 = (switch_thread_data_t *)jarg1; 
+  result =  ((arg1)->func);
+  jresult = new switch_thread_start_t((switch_thread_start_t &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_obj_set(void * jarg1, void * jarg2) {
+  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+  void *arg2 = (void *) 0 ;
+  
+  arg1 = (switch_thread_data_t *)jarg1; 
+  arg2 = (void *)jarg2; 
+  if (arg1) (arg1)->obj = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_obj_get(void * jarg1) {
+  void * jresult ;
+  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+  void *result = 0 ;
+  
+  arg1 = (switch_thread_data_t *)jarg1; 
+  result = (void *) ((arg1)->obj);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_alloc_set(void * jarg1, int jarg2) {
+  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+  int arg2 ;
+  
+  arg1 = (switch_thread_data_t *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->alloc = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_thread_data_t_alloc_get(void * jarg1) {
+  int jresult ;
+  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+  int result;
+  
+  arg1 = (switch_thread_data_t *)jarg1; 
+  result = (int) ((arg1)->alloc);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_thread_data_t() {
+  void * jresult ;
+  switch_thread_data_t *result = 0 ;
+  
+  result = (switch_thread_data_t *)new switch_thread_data_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_thread_data_t(void * jarg1) {
+  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+  
+  arg1 = (switch_thread_data_t *)jarg1; 
+  delete arg1;
+  
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_hold_record_t_on_set(void * jarg1, void * jarg2) {
   switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
   switch_time_t arg2 ;
@@ -6653,95 +6747,741 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_hold_record_t(void * jarg1) {
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_func_set(void * jarg1, void * jarg2) {
-  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
-  switch_thread_start_t arg2 ;
-  switch_thread_start_t *argp2 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_uuid_set(void * jarg1, char * jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  char *arg2 = (char *) 0 ;
   
-  arg1 = (switch_thread_data_t *)jarg1; 
-  argp2 = (switch_thread_start_t *)jarg2; 
-  if (!argp2) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_thread_start_t", 0);
-    return ;
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->uuid) delete [] arg1->uuid;
+    if (arg2) {
+      arg1->uuid = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->uuid, (const char *)arg2);
+    } else {
+      arg1->uuid = 0;
+    }
   }
-  arg2 = *argp2; 
-  if (arg1) (arg1)->func = arg2;
-  
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_func_get(void * jarg1) {
-  void * jresult ;
-  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
-  switch_thread_start_t result;
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_device_node_t_uuid_get(void * jarg1) {
+  char * jresult ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  char *result = 0 ;
   
-  arg1 = (switch_thread_data_t *)jarg1; 
-  result =  ((arg1)->func);
-  jresult = new switch_thread_start_t((switch_thread_start_t &)result); 
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (char *) ((arg1)->uuid);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_obj_set(void * jarg1, void * jarg2) {
-  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
-  void *arg2 = (void *) 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_xml_cdr_set(void * jarg1, void * jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_xml_t arg2 = (switch_xml_t) 0 ;
   
-  arg1 = (switch_thread_data_t *)jarg1; 
-  arg2 = (void *)jarg2; 
-  if (arg1) (arg1)->obj = arg2;
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (switch_xml_t)jarg2; 
+  if (arg1) (arg1)->xml_cdr = arg2;
   
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_obj_get(void * jarg1) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_xml_cdr_get(void * jarg1) {
   void * jresult ;
-  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
-  void *result = 0 ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_xml_t result;
   
-  arg1 = (switch_thread_data_t *)jarg1; 
-  result = (void *) ((arg1)->obj);
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (switch_xml_t) ((arg1)->xml_cdr);
   jresult = (void *)result; 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_alloc_set(void * jarg1, int jarg2) {
-  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
-  int arg2 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_event_set(void * jarg1, void * jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_event_t *arg2 = (switch_event_t *) 0 ;
   
-  arg1 = (switch_thread_data_t *)jarg1; 
-  arg2 = (int)jarg2; 
-  if (arg1) (arg1)->alloc = arg2;
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (switch_event_t *)jarg2; 
+  if (arg1) (arg1)->event = arg2;
   
 }
 
 
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_thread_data_t_alloc_get(void * jarg1) {
-  int jresult ;
-  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
-  int result;
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_event_get(void * jarg1) {
+  void * jresult ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_event_t *result = 0 ;
   
-  arg1 = (switch_thread_data_t *)jarg1; 
-  result = (int) ((arg1)->alloc);
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (switch_event_t *) ((arg1)->event);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_callstate_set(void * jarg1, int jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_channel_callstate_t arg2 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (switch_channel_callstate_t)jarg2; 
+  if (arg1) (arg1)->callstate = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_node_t_callstate_get(void * jarg1) {
+  int jresult ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_channel_callstate_t result;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (switch_channel_callstate_t) ((arg1)->callstate);
   jresult = result; 
   return jresult;
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_thread_data_t() {
-  void * jresult ;
-  switch_thread_data_t *result = 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_hold_record_set(void * jarg1, void * jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_hold_record_t *arg2 = (switch_hold_record_t *) 0 ;
   
-  result = (switch_thread_data_t *)new switch_thread_data_t();
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (switch_hold_record_t *)jarg2; 
+  if (arg1) (arg1)->hold_record = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_hold_record_get(void * jarg1) {
+  void * jresult ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_hold_record_t *result = 0 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (switch_hold_record_t *) ((arg1)->hold_record);
   jresult = (void *)result; 
   return jresult;
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_thread_data_t(void * jarg1) {
-  switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_hup_profile_set(void * jarg1, void * jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_caller_profile_t *arg2 = (switch_caller_profile_t *) 0 ;
   
-  arg1 = (switch_thread_data_t *)jarg1; 
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (switch_caller_profile_t *)jarg2; 
+  if (arg1) (arg1)->hup_profile = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_hup_profile_get(void * jarg1) {
+  void * jresult ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_caller_profile_t *result = 0 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (switch_caller_profile_t *) ((arg1)->hup_profile);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_parent_set(void * jarg1, void * jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_device_record_s *arg2 = (switch_device_record_s *) 0 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (switch_device_record_s *)jarg2; 
+  if (arg1) (arg1)->parent = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_parent_get(void * jarg1) {
+  void * jresult ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  switch_device_record_s *result = 0 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (switch_device_record_s *) ((arg1)->parent);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_next_set(void * jarg1, void * jarg2) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  device_uuid_node_s *arg2 = (device_uuid_node_s *) 0 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  arg2 = (device_uuid_node_s *)jarg2; 
+  if (arg1) (arg1)->next = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_next_get(void * jarg1) {
+  void * jresult ;
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  device_uuid_node_s *result = 0 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  result = (device_uuid_node_s *) ((arg1)->next);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_node_t() {
+  void * jresult ;
+  switch_device_node_t *result = 0 ;
+  
+  result = (switch_device_node_t *)new switch_device_node_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_device_node_t(void * jarg1) {
+  switch_device_node_t *arg1 = (switch_device_node_t *) 0 ;
+  
+  arg1 = (switch_device_node_t *)jarg1; 
+  delete arg1;
+  
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_total_set(void * jarg1, unsigned long jarg2) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->total = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_total_get(void * jarg1) {
+  unsigned long jresult ;
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  result = (uint32_t) ((arg1)->total);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_offhook_set(void * jarg1, unsigned long jarg2) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->offhook = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_offhook_get(void * jarg1) {
+  unsigned long jresult ;
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  result = (uint32_t) ((arg1)->offhook);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_active_set(void * jarg1, unsigned long jarg2) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->active = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_active_get(void * jarg1) {
+  unsigned long jresult ;
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  result = (uint32_t) ((arg1)->active);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_held_set(void * jarg1, unsigned long jarg2) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->held = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_held_get(void * jarg1) {
+  unsigned long jresult ;
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  result = (uint32_t) ((arg1)->held);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_hup_set(void * jarg1, unsigned long jarg2) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->hup = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_hup_get(void * jarg1) {
+  unsigned long jresult ;
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  result = (uint32_t) ((arg1)->hup);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_ringing_set(void * jarg1, unsigned long jarg2) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->ringing = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_ringing_get(void * jarg1) {
+  unsigned long jresult ;
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  result = (uint32_t) ((arg1)->ringing);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_early_set(void * jarg1, unsigned long jarg2) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->early = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_early_get(void * jarg1) {
+  unsigned long jresult ;
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  result = (uint32_t) ((arg1)->early);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_stats_t() {
+  void * jresult ;
+  switch_device_stats_t *result = 0 ;
+  
+  result = (switch_device_stats_t *)new switch_device_stats_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_device_stats_t(void * jarg1) {
+  switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ;
+  
+  arg1 = (switch_device_stats_t *)jarg1; 
+  delete arg1;
+  
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_device_id_set(void * jarg1, char * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->device_id) delete [] arg1->device_id;
+    if (arg2) {
+      arg1->device_id = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->device_id, (const char *)arg2);
+    } else {
+      arg1->device_id = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_device_record_t_device_id_get(void * jarg1) {
+  char * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (char *) ((arg1)->device_id);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_uuid_set(void * jarg1, char * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->uuid) delete [] arg1->uuid;
+    if (arg2) {
+      arg1->uuid = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->uuid, (const char *)arg2);
+    } else {
+      arg1->uuid = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_device_record_t_uuid_get(void * jarg1) {
+  char * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (char *) ((arg1)->uuid);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_refs_set(void * jarg1, int jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  int arg2 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->refs = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_record_t_refs_get(void * jarg1) {
+  int jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  int result;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (int) ((arg1)->refs);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_stats_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_device_stats_t *arg2 = (switch_device_stats_t *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (switch_device_stats_t *)jarg2; 
+  if (arg1) (arg1)->stats = *arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_stats_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_device_stats_t *result = 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (switch_device_stats_t *)& ((arg1)->stats);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_state_set(void * jarg1, int jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_device_state_t arg2 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (switch_device_state_t)jarg2; 
+  if (arg1) (arg1)->state = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_record_t_state_get(void * jarg1) {
+  int jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_device_state_t result;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (switch_device_state_t) ((arg1)->state);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_last_state_set(void * jarg1, int jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_device_state_t arg2 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (switch_device_state_t)jarg2; 
+  if (arg1) (arg1)->last_state = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_record_t_last_state_get(void * jarg1) {
+  int jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_device_state_t result;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (switch_device_state_t) ((arg1)->last_state);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_active_start_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_time_t arg2 ;
+  switch_time_t *argp2 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  argp2 = (switch_time_t *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0);
+    return ;
+  }
+  arg2 = *argp2; 
+  if (arg1) (arg1)->active_start = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_active_start_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_time_t result;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result =  ((arg1)->active_start);
+  jresult = new switch_time_t((switch_time_t &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_active_stop_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_time_t arg2 ;
+  switch_time_t *argp2 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  argp2 = (switch_time_t *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0);
+    return ;
+  }
+  arg2 = *argp2; 
+  if (arg1) (arg1)->active_stop = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_active_stop_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_time_t result;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result =  ((arg1)->active_stop);
+  jresult = new switch_time_t((switch_time_t &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_last_call_time_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_time_t arg2 ;
+  switch_time_t *argp2 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  argp2 = (switch_time_t *)jarg2; 
+  if (!argp2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0);
+    return ;
+  }
+  arg2 = *argp2; 
+  if (arg1) (arg1)->last_call_time = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_last_call_time_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_time_t result;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result =  ((arg1)->last_call_time);
+  jresult = new switch_time_t((switch_time_t &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_uuid_list_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  device_uuid_node_s *arg2 = (device_uuid_node_s *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (device_uuid_node_s *)jarg2; 
+  if (arg1) (arg1)->uuid_list = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_uuid_list_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  device_uuid_node_s *result = 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (device_uuid_node_s *) ((arg1)->uuid_list);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_uuid_tail_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  device_uuid_node_s *arg2 = (device_uuid_node_s *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (device_uuid_node_s *)jarg2; 
+  if (arg1) (arg1)->uuid_tail = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_uuid_tail_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  device_uuid_node_s *result = 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (device_uuid_node_s *) ((arg1)->uuid_tail);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_mutex_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_mutex_t *arg2 = (switch_mutex_t *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (switch_mutex_t *)jarg2; 
+  if (arg1) (arg1)->mutex = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_mutex_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_mutex_t *result = 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (switch_mutex_t *) ((arg1)->mutex);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_pool_set(void * jarg1, void * jarg2) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_memory_pool_t *arg2 = (switch_memory_pool_t *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  arg2 = (switch_memory_pool_t *)jarg2; 
+  if (arg1) (arg1)->pool = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_pool_get(void * jarg1) {
+  void * jresult ;
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  switch_memory_pool_t *result = 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
+  result = (switch_memory_pool_t *) ((arg1)->pool);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_record_t() {
+  void * jresult ;
+  switch_device_record_t *result = 0 ;
+  
+  result = (switch_device_record_t *)new switch_device_record_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_device_record_t(void * jarg1) {
+  switch_device_record_t *arg1 = (switch_device_record_t *) 0 ;
+  
+  arg1 = (switch_device_record_t *)jarg1; 
   delete arg1;
   
 }
@@ -15390,6 +16130,20 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_util_quote_shell_arg(char * jarg1) {
 }
 
 
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_util_quote_shell_arg_pool(char * jarg1, void * jarg2) {
+  char * jresult ;
+  char *arg1 = (char *) 0 ;
+  switch_memory_pool_t *arg2 = (switch_memory_pool_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (char *)jarg1; 
+  arg2 = (switch_memory_pool_t *)jarg2; 
+  result = (char *)switch_util_quote_shell_arg_pool((char const *)arg1,arg2);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT char * SWIGSTDCALL CSharp_switch_url_encode(char * jarg1, char * jarg2, unsigned long jarg3) {
   char * jresult ;
   char *arg1 = (char *) 0 ;
@@ -28481,6 +29235,99 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_handle_cause(void * jarg1, int
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_global_init(void * jarg1) {
+  switch_memory_pool_t *arg1 = (switch_memory_pool_t *) 0 ;
+  
+  arg1 = (switch_memory_pool_t *)jarg1; 
+  switch_channel_global_init(arg1);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_global_uninit() {
+  switch_channel_global_uninit();
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_channel_set_device_id(void * jarg1, char * jarg2) {
+  char * jresult ;
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (char *)switch_channel_set_device_id(arg1,(char const *)arg2);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_clear_device_record(void * jarg1) {
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  switch_channel_clear_device_record(arg1);
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_channel_get_device_record(void * jarg1) {
+  void * jresult ;
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  switch_device_record_t *result = 0 ;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  result = (switch_device_record_t *)switch_channel_get_device_record(arg1);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_release_device_record(void * jarg1) {
+  switch_device_record_t **arg1 = (switch_device_record_t **) 0 ;
+  
+  arg1 = (switch_device_record_t **)jarg1; 
+  switch_channel_release_device_record(arg1);
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_bind_device_state_handler(void * jarg1, void * jarg2) {
+  int jresult ;
+  switch_device_state_function_t arg1 = (switch_device_state_function_t) 0 ;
+  void *arg2 = (void *) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_device_state_function_t)jarg1; 
+  arg2 = (void *)jarg2; 
+  result = (switch_status_t)switch_channel_bind_device_state_handler(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_unbind_device_state_handler(void * jarg1) {
+  int jresult ;
+  switch_device_state_function_t arg1 = (switch_device_state_function_t) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_device_state_function_t)jarg1; 
+  result = (switch_status_t)switch_channel_unbind_device_state_handler(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_channel_device_state2str(int jarg1) {
+  char * jresult ;
+  switch_device_state_t arg1 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_device_state_t)jarg1; 
+  result = (char *)switch_channel_device_state2str(arg1);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_buffer_create(void * jarg1, void * jarg2, void * jarg3) {
   int jresult ;
   switch_memory_pool_t *arg1 = (switch_memory_pool_t *) 0 ;
diff --git a/src/mod/languages/mod_managed/managed/swig.cs b/src/mod/languages/mod_managed/managed/swig.cs
index 7e8f5663a9..21f0e31989 100644
--- a/src/mod/languages/mod_managed/managed/swig.cs
+++ b/src/mod/languages/mod_managed/managed/swig.cs
@@ -1776,6 +1776,36 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
 public class SWIGTYPE_p_f_p_switch_core_session_enum_switch_media_type_t__p_stfu_instance_t {
   private HandleRef swigCPtr;
 
@@ -4146,6 +4176,36 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class SWIGTYPE_p_p_switch_device_record_s {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_switch_device_record_s(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_switch_device_record_s() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_switch_device_record_s obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
 public class SWIGTYPE_p_p_switch_event {
   private HandleRef swigCPtr;
 
@@ -9258,6 +9318,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static string switch_util_quote_shell_arg_pool(string arg0, SWIGTYPE_p_apr_pool_t pool) {
+    string ret = freeswitchPINVOKE.switch_util_quote_shell_arg_pool(arg0, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
+    return ret;
+  }
+
   public static string switch_url_encode(string url, string buf, uint len) {
     string ret = freeswitchPINVOKE.switch_url_encode(url, buf, len);
     return ret;
@@ -10075,6 +10140,48 @@ public class freeswitch {
     freeswitchPINVOKE.switch_channel_handle_cause(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)cause);
   }
 
+  public static void switch_channel_global_init(SWIGTYPE_p_apr_pool_t pool) {
+    freeswitchPINVOKE.switch_channel_global_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool));
+  }
+
+  public static void switch_channel_global_uninit() {
+    freeswitchPINVOKE.switch_channel_global_uninit();
+  }
+
+  public static string switch_channel_set_device_id(SWIGTYPE_p_switch_channel channel, string device_id) {
+    string ret = freeswitchPINVOKE.switch_channel_set_device_id(SWIGTYPE_p_switch_channel.getCPtr(channel), device_id);
+    return ret;
+  }
+
+  public static void switch_channel_clear_device_record(SWIGTYPE_p_switch_channel channel) {
+    freeswitchPINVOKE.switch_channel_clear_device_record(SWIGTYPE_p_switch_channel.getCPtr(channel));
+  }
+
+  public static switch_device_record_t switch_channel_get_device_record(SWIGTYPE_p_switch_channel channel) {
+    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_device_record(SWIGTYPE_p_switch_channel.getCPtr(channel));
+    switch_device_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_record_t(cPtr, false);
+    return ret;
+  }
+
+  public static void switch_channel_release_device_record(SWIGTYPE_p_p_switch_device_record_s dcdrp) {
+    freeswitchPINVOKE.switch_channel_release_device_record(SWIGTYPE_p_p_switch_device_record_s.getCPtr(dcdrp));
+  }
+
+  public static switch_status_t switch_channel_bind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void function, SWIGTYPE_p_void user_data) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_bind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void.getCPtr(function), SWIGTYPE_p_void.getCPtr(user_data));
+    return ret;
+  }
+
+  public static switch_status_t switch_channel_unbind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void function) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_unbind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void.getCPtr(function));
+    return ret;
+  }
+
+  public static string switch_channel_device_state2str(switch_device_state_t device_state) {
+    string ret = freeswitchPINVOKE.switch_channel_device_state2str((int)device_state);
+    return ret;
+  }
+
   public static switch_status_t switch_buffer_create(SWIGTYPE_p_apr_pool_t pool, SWIGTYPE_p_p_switch_buffer buffer, SWIGTYPE_p_switch_size_t max_len) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_buffer_create(SWIGTYPE_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_switch_size_t.getCPtr(max_len));
     if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
@@ -14014,6 +14121,30 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_app_log")]
   public static extern void delete_switch_app_log(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_set")]
+  public static extern void switch_thread_data_t_func_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_get")]
+  public static extern IntPtr switch_thread_data_t_func_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_set")]
+  public static extern void switch_thread_data_t_obj_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_get")]
+  public static extern IntPtr switch_thread_data_t_obj_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_set")]
+  public static extern void switch_thread_data_t_alloc_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_get")]
+  public static extern int switch_thread_data_t_alloc_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_thread_data_t")]
+  public static extern IntPtr new_switch_thread_data_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_thread_data_t")]
+  public static extern void delete_switch_thread_data_t(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_on_set")]
   public static extern void switch_hold_record_t_on_set(HandleRef jarg1, HandleRef jarg2);
 
@@ -14044,29 +14175,191 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_hold_record_t")]
   public static extern void delete_switch_hold_record_t(HandleRef jarg1);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_set")]
-  public static extern void switch_thread_data_t_func_set(HandleRef jarg1, HandleRef jarg2);
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_uuid_set")]
+  public static extern void switch_device_node_t_uuid_set(HandleRef jarg1, string jarg2);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_get")]
-  public static extern IntPtr switch_thread_data_t_func_get(HandleRef jarg1);
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_uuid_get")]
+  public static extern string switch_device_node_t_uuid_get(HandleRef jarg1);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_set")]
-  public static extern void switch_thread_data_t_obj_set(HandleRef jarg1, HandleRef jarg2);
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_xml_cdr_set")]
+  public static extern void switch_device_node_t_xml_cdr_set(HandleRef jarg1, HandleRef jarg2);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_get")]
-  public static extern IntPtr switch_thread_data_t_obj_get(HandleRef jarg1);
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_xml_cdr_get")]
+  public static extern IntPtr switch_device_node_t_xml_cdr_get(HandleRef jarg1);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_set")]
-  public static extern void switch_thread_data_t_alloc_set(HandleRef jarg1, int jarg2);
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_event_set")]
+  public static extern void switch_device_node_t_event_set(HandleRef jarg1, HandleRef jarg2);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_get")]
-  public static extern int switch_thread_data_t_alloc_get(HandleRef jarg1);
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_event_get")]
+  public static extern IntPtr switch_device_node_t_event_get(HandleRef jarg1);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_thread_data_t")]
-  public static extern IntPtr new_switch_thread_data_t();
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_callstate_set")]
+  public static extern void switch_device_node_t_callstate_set(HandleRef jarg1, int jarg2);
 
-  [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_thread_data_t")]
-  public static extern void delete_switch_thread_data_t(HandleRef jarg1);
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_callstate_get")]
+  public static extern int switch_device_node_t_callstate_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hold_record_set")]
+  public static extern void switch_device_node_t_hold_record_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hold_record_get")]
+  public static extern IntPtr switch_device_node_t_hold_record_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hup_profile_set")]
+  public static extern void switch_device_node_t_hup_profile_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hup_profile_get")]
+  public static extern IntPtr switch_device_node_t_hup_profile_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_parent_set")]
+  public static extern void switch_device_node_t_parent_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_parent_get")]
+  public static extern IntPtr switch_device_node_t_parent_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_next_set")]
+  public static extern void switch_device_node_t_next_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_next_get")]
+  public static extern IntPtr switch_device_node_t_next_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_node_t")]
+  public static extern IntPtr new_switch_device_node_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_device_node_t")]
+  public static extern void delete_switch_device_node_t(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_set")]
+  public static extern void switch_device_stats_t_total_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_get")]
+  public static extern uint switch_device_stats_t_total_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_set")]
+  public static extern void switch_device_stats_t_offhook_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_get")]
+  public static extern uint switch_device_stats_t_offhook_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_set")]
+  public static extern void switch_device_stats_t_active_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_get")]
+  public static extern uint switch_device_stats_t_active_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_set")]
+  public static extern void switch_device_stats_t_held_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_get")]
+  public static extern uint switch_device_stats_t_held_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_set")]
+  public static extern void switch_device_stats_t_hup_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_get")]
+  public static extern uint switch_device_stats_t_hup_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_set")]
+  public static extern void switch_device_stats_t_ringing_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_get")]
+  public static extern uint switch_device_stats_t_ringing_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_set")]
+  public static extern void switch_device_stats_t_early_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_get")]
+  public static extern uint switch_device_stats_t_early_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_stats_t")]
+  public static extern IntPtr new_switch_device_stats_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_device_stats_t")]
+  public static extern void delete_switch_device_stats_t(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_device_id_set")]
+  public static extern void switch_device_record_t_device_id_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_device_id_get")]
+  public static extern string switch_device_record_t_device_id_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_set")]
+  public static extern void switch_device_record_t_uuid_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_get")]
+  public static extern string switch_device_record_t_uuid_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_refs_set")]
+  public static extern void switch_device_record_t_refs_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_refs_get")]
+  public static extern int switch_device_record_t_refs_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_stats_set")]
+  public static extern void switch_device_record_t_stats_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_stats_get")]
+  public static extern IntPtr switch_device_record_t_stats_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_state_set")]
+  public static extern void switch_device_record_t_state_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_state_get")]
+  public static extern int switch_device_record_t_state_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_state_set")]
+  public static extern void switch_device_record_t_last_state_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_state_get")]
+  public static extern int switch_device_record_t_last_state_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_start_set")]
+  public static extern void switch_device_record_t_active_start_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_start_get")]
+  public static extern IntPtr switch_device_record_t_active_start_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_stop_set")]
+  public static extern void switch_device_record_t_active_stop_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_stop_get")]
+  public static extern IntPtr switch_device_record_t_active_stop_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_call_time_set")]
+  public static extern void switch_device_record_t_last_call_time_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_call_time_get")]
+  public static extern IntPtr switch_device_record_t_last_call_time_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_list_set")]
+  public static extern void switch_device_record_t_uuid_list_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_list_get")]
+  public static extern IntPtr switch_device_record_t_uuid_list_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_tail_set")]
+  public static extern void switch_device_record_t_uuid_tail_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_tail_get")]
+  public static extern IntPtr switch_device_record_t_uuid_tail_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_mutex_set")]
+  public static extern void switch_device_record_t_mutex_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_mutex_get")]
+  public static extern IntPtr switch_device_record_t_mutex_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_pool_set")]
+  public static extern void switch_device_record_t_pool_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_pool_get")]
+  public static extern IntPtr switch_device_record_t_pool_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_record_t")]
+  public static extern IntPtr new_switch_device_record_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_device_record_t")]
+  public static extern void delete_switch_device_record_t(HandleRef jarg1);
 
   [DllImport("mod_managed", EntryPoint="CSharp_MESSAGE_STRING_ARG_MAX_get")]
   public static extern int MESSAGE_STRING_ARG_MAX_get();
@@ -16018,6 +16311,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_util_quote_shell_arg")]
   public static extern string switch_util_quote_shell_arg(string jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_util_quote_shell_arg_pool")]
+  public static extern string switch_util_quote_shell_arg_pool(string jarg1, HandleRef jarg2);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_url_encode")]
   public static extern string switch_url_encode(string jarg1, string jarg2, uint jarg3);
 
@@ -19219,6 +19515,33 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_handle_cause")]
   public static extern void switch_channel_handle_cause(HandleRef jarg1, int jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_global_init")]
+  public static extern void switch_channel_global_init(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_global_uninit")]
+  public static extern void switch_channel_global_uninit();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_device_id")]
+  public static extern string switch_channel_set_device_id(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_clear_device_record")]
+  public static extern void switch_channel_clear_device_record(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_device_record")]
+  public static extern IntPtr switch_channel_get_device_record(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_release_device_record")]
+  public static extern void switch_channel_release_device_record(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_bind_device_state_handler")]
+  public static extern int switch_channel_bind_device_state_handler(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_unbind_device_state_handler")]
+  public static extern int switch_channel_unbind_device_state_handler(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_device_state2str")]
+  public static extern string switch_channel_device_state2str(int jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_buffer_create")]
   public static extern int switch_buffer_create(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
 
@@ -24554,7 +24877,8 @@ public enum switch_channel_callstate_t {
   CCS_EARLY,
   CCS_ACTIVE,
   CCS_HELD,
-  CCS_HANGUP
+  CCS_HANGUP,
+  CCS_UNHOLD
 }
 
 }
@@ -24666,6 +24990,8 @@ public enum switch_channel_flag_t {
   CF_ZRTP_PASSTHRU,
   CF_ZRTP_HASH,
   CF_CHANNEL_SWAP,
+  CF_DEVICE_LEG,
+  CF_FINAL_DEVICE_LEG,
   CF_PICKUP,
   CF_CONFIRM_BLIND_TRANSFER,
   CF_NO_PRESENCE,
@@ -26834,6 +27160,464 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class switch_device_node_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal switch_device_node_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(switch_device_node_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~switch_device_node_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_switch_device_node_t(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public string uuid {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_uuid_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_device_node_t_uuid_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_xml xml_cdr {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_xml_cdr_set(swigCPtr, switch_xml.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_xml_cdr_get(swigCPtr);
+      switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_event event {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_event_set(swigCPtr, switch_event.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_event_get(swigCPtr);
+      switch_event ret = (cPtr == IntPtr.Zero) ? null : new switch_event(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_channel_callstate_t callstate {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_callstate_set(swigCPtr, (int)value);
+    } 
+    get {
+      switch_channel_callstate_t ret = (switch_channel_callstate_t)freeswitchPINVOKE.switch_device_node_t_callstate_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_hold_record_t hold_record {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_hold_record_set(swigCPtr, switch_hold_record_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_hold_record_get(swigCPtr);
+      switch_hold_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_hold_record_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_caller_profile hup_profile {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_hup_profile_set(swigCPtr, switch_caller_profile.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_hup_profile_get(swigCPtr);
+      switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_device_record_t parent {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_parent_set(swigCPtr, switch_device_record_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_parent_get(swigCPtr);
+      switch_device_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_record_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_device_node_t next {
+    set {
+      freeswitchPINVOKE.switch_device_node_t_next_set(swigCPtr, switch_device_node_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_next_get(swigCPtr);
+      switch_device_node_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_node_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_device_node_t() : this(freeswitchPINVOKE.new_switch_device_node_t(), true) {
+  }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class switch_device_record_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal switch_device_record_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(switch_device_record_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~switch_device_record_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_switch_device_record_t(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public string device_id {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_device_id_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_device_record_t_device_id_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string uuid {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_uuid_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_device_record_t_uuid_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public int refs {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_refs_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.switch_device_record_t_refs_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_device_stats_t stats {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_stats_set(swigCPtr, switch_device_stats_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_stats_get(swigCPtr);
+      switch_device_stats_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_stats_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_device_state_t state {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_state_set(swigCPtr, (int)value);
+    } 
+    get {
+      switch_device_state_t ret = (switch_device_state_t)freeswitchPINVOKE.switch_device_record_t_state_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_device_state_t last_state {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_last_state_set(swigCPtr, (int)value);
+    } 
+    get {
+      switch_device_state_t ret = (switch_device_state_t)freeswitchPINVOKE.switch_device_record_t_last_state_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_switch_time_t active_start {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_active_start_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value));
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+    } 
+    get {
+      SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_active_start_get(swigCPtr), true);
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_switch_time_t active_stop {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_active_stop_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value));
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+    } 
+    get {
+      SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_active_stop_get(swigCPtr), true);
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_switch_time_t last_call_time {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_last_call_time_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value));
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+    } 
+    get {
+      SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_last_call_time_get(swigCPtr), true);
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    } 
+  }
+
+  public switch_device_node_t uuid_list {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_uuid_list_set(swigCPtr, switch_device_node_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_uuid_list_get(swigCPtr);
+      switch_device_node_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_node_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_device_node_t uuid_tail {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_uuid_tail_set(swigCPtr, switch_device_node_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_uuid_tail_get(swigCPtr);
+      switch_device_node_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_node_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_switch_mutex_t mutex {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_mutex_set(swigCPtr, SWIGTYPE_p_switch_mutex_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_mutex_get(swigCPtr);
+      SWIGTYPE_p_switch_mutex_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_mutex_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_apr_pool_t pool {
+    set {
+      freeswitchPINVOKE.switch_device_record_t_pool_set(swigCPtr, SWIGTYPE_p_apr_pool_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_pool_get(swigCPtr);
+      SWIGTYPE_p_apr_pool_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_apr_pool_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_device_record_t() : this(freeswitchPINVOKE.new_switch_device_record_t(), true) {
+  }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+public enum switch_device_state_t {
+  SDS_DOWN,
+  SDS_RINGING,
+  SDS_ACTIVE,
+  SDS_ACTIVE_MULTI,
+  SDS_HELD,
+  SDS_HANGUP
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class switch_device_stats_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal switch_device_stats_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(switch_device_stats_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~switch_device_stats_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_switch_device_stats_t(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public uint total {
+    set {
+      freeswitchPINVOKE.switch_device_stats_t_total_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.switch_device_stats_t_total_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public uint offhook {
+    set {
+      freeswitchPINVOKE.switch_device_stats_t_offhook_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.switch_device_stats_t_offhook_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public uint active {
+    set {
+      freeswitchPINVOKE.switch_device_stats_t_active_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.switch_device_stats_t_active_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public uint held {
+    set {
+      freeswitchPINVOKE.switch_device_stats_t_held_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.switch_device_stats_t_held_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public uint hup {
+    set {
+      freeswitchPINVOKE.switch_device_stats_t_hup_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.switch_device_stats_t_hup_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public uint ringing {
+    set {
+      freeswitchPINVOKE.switch_device_stats_t_ringing_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.switch_device_stats_t_ringing_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public uint early {
+    set {
+      freeswitchPINVOKE.switch_device_stats_t_early_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.switch_device_stats_t_early_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_device_stats_t() : this(freeswitchPINVOKE.new_switch_device_stats_t(), true) {
+  }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
 public class switch_dialplan_interface : IDisposable {
   private HandleRef swigCPtr;
   protected bool swigCMemOwn;
@@ -28106,6 +28890,8 @@ public enum switch_event_types_t {
   SWITCH_EVENT_CONFERENCE_DATA,
   SWITCH_EVENT_CALL_SETUP_REQ,
   SWITCH_EVENT_CALL_SETUP_RESULT,
+  SWITCH_EVENT_CALL_DETAIL,
+  SWITCH_EVENT_DEVICE_STATE,
   SWITCH_EVENT_ALL
 }