From dba0b0e40aacd25b409e8fada2bfc939637fac94 Mon Sep 17 00:00:00 2001
From: Jeff Lenk <jeff@jefflenk.com>
Date: Fri, 14 Sep 2012 12:28:15 -0500
Subject: [PATCH] vs2010 reswig

---
 .../mod_managed/freeswitch_wrap.2010.cxx      | 440 ++++++++++++++++++
 .../mod_managed/managed/swig.2010.cs          | 403 +++++++++++++++-
 2 files changed, 842 insertions(+), 1 deletion(-)

diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx
index c04fa86d95..567ac0f0e8 100644
--- a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx
+++ b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx
@@ -5894,6 +5894,132 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_app_log(void * jarg1) {
 }
 
 
+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 ;
+  switch_time_t *argp2 ;
+  
+  arg1 = (switch_hold_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)->on = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_hold_record_t_on_get(void * jarg1) {
+  void * jresult ;
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  switch_time_t result;
+  
+  arg1 = (switch_hold_record_t *)jarg1; 
+  result =  ((arg1)->on);
+  jresult = new switch_time_t((const switch_time_t &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_hold_record_t_off_set(void * jarg1, void * jarg2) {
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  switch_time_t arg2 ;
+  switch_time_t *argp2 ;
+  
+  arg1 = (switch_hold_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)->off = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_hold_record_t_off_get(void * jarg1) {
+  void * jresult ;
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  switch_time_t result;
+  
+  arg1 = (switch_hold_record_t *)jarg1; 
+  result =  ((arg1)->off);
+  jresult = new switch_time_t((const switch_time_t &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_hold_record_t_uuid_set(void * jarg1, char * jarg2) {
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_hold_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_hold_record_t_uuid_get(void * jarg1) {
+  char * jresult ;
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_hold_record_t *)jarg1; 
+  result = (char *) ((arg1)->uuid);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_hold_record_t_next_set(void * jarg1, void * jarg2) {
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  switch_hold_record_s *arg2 = (switch_hold_record_s *) 0 ;
+  
+  arg1 = (switch_hold_record_t *)jarg1; 
+  arg2 = (switch_hold_record_s *)jarg2; 
+  if (arg1) (arg1)->next = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_hold_record_t_next_get(void * jarg1) {
+  void * jresult ;
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  switch_hold_record_s *result = 0 ;
+  
+  arg1 = (switch_hold_record_t *)jarg1; 
+  result = (switch_hold_record_s *) ((arg1)->next);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_hold_record_t() {
+  void * jresult ;
+  switch_hold_record_t *result = 0 ;
+  
+  result = (switch_hold_record_t *)new switch_hold_record_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_hold_record_t(void * jarg1) {
+  switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ;
+  
+  arg1 = (switch_hold_record_t *)jarg1; 
+  delete arg1;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_MESSAGE_STRING_ARG_MAX_get() {
   int jresult ;
   int result;
@@ -7591,6 +7717,16 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_id() {
 }
 
 
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_id_dec() {
+  void * jresult ;
+  switch_size_t result;
+  
+  result = switch_core_session_id_dec();
+  jresult = new switch_size_t((const switch_size_t &)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_request_by_name(char * jarg1, int jarg2, void * jarg3) {
   void * jresult ;
   char *arg1 = (char *) 0 ;
@@ -26110,6 +26246,18 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_channel_get_partner_uuid(void * jarg
 }
 
 
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_channel_get_hold_record(void * jarg1) {
+  void * jresult ;
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  switch_hold_record_t *result = 0 ;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  result = (switch_hold_record_t *)switch_channel_get_hold_record(arg1);
+  jresult = (void *)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 ;
@@ -26906,6 +27054,258 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_event(void * jarg1) {
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_t_event_id_set(void * jarg1, int jarg2) {
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  int arg2 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->event_id = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_serial_event_t_event_id_get(void * jarg1) {
+  int jresult ;
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  int result;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  result = (int) ((arg1)->event_id);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_t_priority_set(void * jarg1, int jarg2) {
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  int arg2 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->priority = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_serial_event_t_priority_get(void * jarg1) {
+  int jresult ;
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  int result;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  result = (int) ((arg1)->priority);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_t_flags_set(void * jarg1, int jarg2) {
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  int arg2 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->flags = arg2;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_serial_event_t_flags_get(void * jarg1) {
+  int jresult ;
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  int result;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  result = (int) ((arg1)->flags);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_t_owner_set(void * jarg1, char * jarg2) {
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->owner) delete [] arg1->owner;
+    if (arg2) {
+      arg1->owner = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->owner, (const char *)arg2);
+    } else {
+      arg1->owner = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_serial_event_t_owner_get(void * jarg1) {
+  char * jresult ;
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  result = (char *) ((arg1)->owner);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_t_subclass_name_set(void * jarg1, char * jarg2) {
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->subclass_name) delete [] arg1->subclass_name;
+    if (arg2) {
+      arg1->subclass_name = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->subclass_name, (const char *)arg2);
+    } else {
+      arg1->subclass_name = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_serial_event_t_subclass_name_get(void * jarg1) {
+  char * jresult ;
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  result = (char *) ((arg1)->subclass_name);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_t_body_set(void * jarg1, char * jarg2) {
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->body) delete [] arg1->body;
+    if (arg2) {
+      arg1->body = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->body, (const char *)arg2);
+    } else {
+      arg1->body = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_serial_event_t_body_get(void * jarg1) {
+  char * jresult ;
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  result = (char *) ((arg1)->body);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_serial_event_t() {
+  void * jresult ;
+  switch_serial_event_t *result = 0 ;
+  
+  result = (switch_serial_event_t *)new switch_serial_event_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_serial_event_t(void * jarg1) {
+  switch_serial_event_t *arg1 = (switch_serial_event_t *) 0 ;
+  
+  arg1 = (switch_serial_event_t *)jarg1; 
+  delete arg1;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_header_t_name_set(void * jarg1, char * jarg2) {
+  switch_serial_event_header_t *arg1 = (switch_serial_event_header_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_serial_event_header_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->name) delete [] arg1->name;
+    if (arg2) {
+      arg1->name = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->name, (const char *)arg2);
+    } else {
+      arg1->name = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_serial_event_header_t_name_get(void * jarg1) {
+  char * jresult ;
+  switch_serial_event_header_t *arg1 = (switch_serial_event_header_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_serial_event_header_t *)jarg1; 
+  result = (char *) ((arg1)->name);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_serial_event_header_t_value_set(void * jarg1, char * jarg2) {
+  switch_serial_event_header_t *arg1 = (switch_serial_event_header_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_serial_event_header_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->value) delete [] arg1->value;
+    if (arg2) {
+      arg1->value = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->value, (const char *)arg2);
+    } else {
+      arg1->value = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_serial_event_header_t_value_get(void * jarg1) {
+  char * jresult ;
+  switch_serial_event_header_t *arg1 = (switch_serial_event_header_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_serial_event_header_t *)jarg1; 
+  result = (char *) ((arg1)->value);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_serial_event_header_t() {
+  void * jresult ;
+  switch_serial_event_header_t *result = 0 ;
+  
+  result = (switch_serial_event_header_t *)new switch_serial_event_header_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_serial_event_header_t(void * jarg1) {
+  switch_serial_event_header_t *arg1 = (switch_serial_event_header_t *) 0 ;
+  
+  arg1 = (switch_serial_event_header_t *)jarg1; 
+  delete arg1;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_init(void * jarg1) {
   int jresult ;
   switch_memory_pool_t *arg1 = (switch_memory_pool_t *) 0 ;
@@ -27286,6 +27686,46 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_free_subclass_detailed(char * jar
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_binary_deserialize(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
+  int jresult ;
+  switch_event_t **arg1 = (switch_event_t **) 0 ;
+  void **arg2 = (void **) 0 ;
+  switch_size_t arg3 ;
+  switch_bool_t arg4 ;
+  switch_size_t *argp3 ;
+  switch_status_t result;
+  
+  arg1 = (switch_event_t **)jarg1; 
+  arg2 = (void **)jarg2; 
+  argp3 = (switch_size_t *)jarg3; 
+  if (!argp3) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_size_t", 0);
+    return 0;
+  }
+  arg3 = *argp3; 
+  arg4 = (switch_bool_t)jarg4; 
+  result = (switch_status_t)switch_event_binary_deserialize(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_binary_serialize(void * jarg1, void * jarg2, void * jarg3) {
+  int jresult ;
+  switch_event_t *arg1 = (switch_event_t *) 0 ;
+  void **arg2 = (void **) 0 ;
+  switch_size_t *arg3 = (switch_size_t *) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_event_t *)jarg1; 
+  arg2 = (void **)jarg2; 
+  arg3 = (switch_size_t *)jarg3; 
+  result = (switch_status_t)switch_event_binary_serialize(arg1,arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_event_serialize(void * jarg1, void * jarg2, int jarg3) {
   int jresult ;
   switch_event_t *arg1 = (switch_event_t *) 0 ;
diff --git a/src/mod/languages/mod_managed/managed/swig.2010.cs b/src/mod/languages/mod_managed/managed/swig.2010.cs
index 4c3360c043..8fcc92d7e4 100644
--- a/src/mod/languages/mod_managed/managed/swig.2010.cs
+++ b/src/mod/languages/mod_managed/managed/swig.2010.cs
@@ -1449,6 +1449,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static SWIGTYPE_p_switch_size_t switch_core_session_id_dec() {
+    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_core_session_id_dec(), true);
+    return ret;
+  }
+
   public static SWIGTYPE_p_switch_core_session switch_core_session_request_by_name(string endpoint_name, switch_call_direction_t direction, SWIGTYPE_p_p_apr_pool_t pool) {
     IntPtr cPtr = freeswitchPINVOKE.switch_core_session_request_by_name(endpoint_name, (int)direction, SWIGTYPE_p_p_apr_pool_t.getCPtr(pool));
     SWIGTYPE_p_switch_core_session ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_core_session(cPtr, false);
@@ -4188,6 +4193,12 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_hold_record_t switch_channel_get_hold_record(SWIGTYPE_p_switch_channel channel) {
+    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_hold_record(SWIGTYPE_p_switch_channel.getCPtr(channel));
+    switch_hold_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_hold_record_t(cPtr, false);
+    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();
@@ -4419,6 +4430,17 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_status_t switch_event_binary_deserialize(SWIGTYPE_p_p_switch_event eventp, SWIGTYPE_p_p_void data, SWIGTYPE_p_switch_size_t len, switch_bool_t destroy) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_binary_deserialize(SWIGTYPE_p_p_switch_event.getCPtr(eventp), SWIGTYPE_p_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(len), (int)destroy);
+    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
+  public static switch_status_t switch_event_binary_serialize(switch_event arg0, SWIGTYPE_p_p_void data, SWIGTYPE_p_switch_size_t len) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_binary_serialize(switch_event.getCPtr(arg0), SWIGTYPE_p_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(len));
+    return ret;
+  }
+
   public static switch_status_t switch_event_serialize(switch_event arg0, ref string str, switch_bool_t encode) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_serialize(switch_event.getCPtr(arg0), ref str, (int)encode);
     return ret;
@@ -7978,6 +8000,36 @@ 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_hold_record_t_on_set")]
+  public static extern void switch_hold_record_t_on_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_on_get")]
+  public static extern IntPtr switch_hold_record_t_on_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_off_set")]
+  public static extern void switch_hold_record_t_off_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_off_get")]
+  public static extern IntPtr switch_hold_record_t_off_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_uuid_set")]
+  public static extern void switch_hold_record_t_uuid_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_uuid_get")]
+  public static extern string switch_hold_record_t_uuid_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_next_set")]
+  public static extern void switch_hold_record_t_next_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_next_get")]
+  public static extern IntPtr switch_hold_record_t_next_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_hold_record_t")]
+  public static extern IntPtr new_switch_hold_record_t();
+
+  [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_MESSAGE_STRING_ARG_MAX_get")]
   public static extern int MESSAGE_STRING_ARG_MAX_get();
 
@@ -8374,6 +8426,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_id")]
   public static extern IntPtr switch_core_session_id();
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_id_dec")]
+  public static extern IntPtr switch_core_session_id_dec();
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_request_by_name")]
   public static extern IntPtr switch_core_session_request_by_name(string jarg1, int jarg2, HandleRef jarg3);
 
@@ -12865,6 +12920,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_partner_uuid")]
   public static extern string switch_channel_get_partner_uuid(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_hold_record")]
+  public static extern IntPtr switch_channel_get_hold_record(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_buffer_create")]
   public static extern int switch_buffer_create(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
 
@@ -13045,6 +13103,66 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_event")]
   public static extern void delete_switch_event(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_event_id_set")]
+  public static extern void switch_serial_event_t_event_id_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_event_id_get")]
+  public static extern int switch_serial_event_t_event_id_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_priority_set")]
+  public static extern void switch_serial_event_t_priority_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_priority_get")]
+  public static extern int switch_serial_event_t_priority_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_flags_set")]
+  public static extern void switch_serial_event_t_flags_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_flags_get")]
+  public static extern int switch_serial_event_t_flags_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_owner_set")]
+  public static extern void switch_serial_event_t_owner_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_owner_get")]
+  public static extern string switch_serial_event_t_owner_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_subclass_name_set")]
+  public static extern void switch_serial_event_t_subclass_name_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_subclass_name_get")]
+  public static extern string switch_serial_event_t_subclass_name_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_body_set")]
+  public static extern void switch_serial_event_t_body_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_t_body_get")]
+  public static extern string switch_serial_event_t_body_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_serial_event_t")]
+  public static extern IntPtr new_switch_serial_event_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_serial_event_t")]
+  public static extern void delete_switch_serial_event_t(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_header_t_name_set")]
+  public static extern void switch_serial_event_header_t_name_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_header_t_name_get")]
+  public static extern string switch_serial_event_header_t_name_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_header_t_value_set")]
+  public static extern void switch_serial_event_header_t_value_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_serial_event_header_t_value_get")]
+  public static extern string switch_serial_event_header_t_value_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_switch_serial_event_header_t")]
+  public static extern IntPtr new_switch_serial_event_header_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_serial_event_header_t")]
+  public static extern void delete_switch_serial_event_header_t(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_event_init")]
   public static extern int switch_event_init(HandleRef jarg1);
 
@@ -13123,6 +13241,12 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_event_free_subclass_detailed")]
   public static extern int switch_event_free_subclass_detailed(string jarg1, string jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_event_binary_deserialize")]
+  public static extern int switch_event_binary_deserialize(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, int jarg4);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_event_binary_serialize")]
+  public static extern int switch_event_binary_serialize(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_event_serialize")]
   public static extern int switch_event_serialize(HandleRef jarg1, ref string jarg2, int jarg3);
 
@@ -23225,7 +23349,8 @@ public enum switch_call_cause_t {
   SWITCH_CAUSE_INVALID_GATEWAY = 608,
   SWITCH_CAUSE_GATEWAY_DOWN = 609,
   SWITCH_CAUSE_INVALID_URL = 610,
-  SWITCH_CAUSE_INVALID_PROFILE = 611
+  SWITCH_CAUSE_INVALID_PROFILE = 611,
+  SWITCH_CAUSE_NO_PICKUP = 612
 }
 
 }
@@ -23399,6 +23524,8 @@ public enum switch_channel_flag_t {
   CF_RECOVERING_BRIDGE,
   CF_TRACKED,
   CF_TRACKABLE,
+  CF_NO_CDR,
+  CF_EARLY_OK,
   CF_FLAG_MAX
 }
 
@@ -25316,10 +25443,12 @@ public enum switch_core_session_message_types_t {
   SWITCH_MESSAGE_INDICATE_JITTER_BUFFER,
   SWITCH_MESSAGE_INDICATE_RECOVERY_REFRESH,
   SWITCH_MESSAGE_INDICATE_SIGNAL_DATA,
+  SWITCH_MESSAGE_INDICATE_MESSAGE,
   SWITCH_MESSAGE_INDICATE_INFO,
   SWITCH_MESSAGE_INDICATE_AUDIO_DATA,
   SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE,
   SWITCH_MESSAGE_INDICATE_STUN_ERROR,
+  SWITCH_MESSAGE_INDICATE_MEDIA_RENEG,
   SWITCH_MESSAGE_INVALID
 }
 
@@ -27817,6 +27946,100 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class switch_hold_record_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal switch_hold_record_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(switch_hold_record_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~switch_hold_record_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if (swigCPtr.Handle != IntPtr.Zero) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          freeswitchPINVOKE.delete_switch_hold_record_t(swigCPtr);
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public SWIGTYPE_p_switch_time_t on {
+    set {
+      freeswitchPINVOKE.switch_hold_record_t_on_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_hold_record_t_on_get(swigCPtr), true);
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_switch_time_t off {
+    set {
+      freeswitchPINVOKE.switch_hold_record_t_off_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_hold_record_t_off_get(swigCPtr), true);
+      if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+      return ret;
+    } 
+  }
+
+  public string uuid {
+    set {
+      freeswitchPINVOKE.switch_hold_record_t_uuid_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_hold_record_t_uuid_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_hold_record_t next {
+    set {
+      freeswitchPINVOKE.switch_hold_record_t_next_set(swigCPtr, switch_hold_record_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_hold_record_t_next_get(swigCPtr);
+      switch_hold_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_hold_record_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_hold_record_t() : this(freeswitchPINVOKE.new_switch_hold_record_t(), true) {
+  }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 2.0.1
+ *
+ * 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_input_args_t : IDisposable {
   private HandleRef swigCPtr;
   protected bool swigCMemOwn;
@@ -31610,6 +31833,184 @@ public class switch_scheduler_task : IDisposable {
 
 namespace FreeSWITCH.Native {
 
+using System;
+using System.Runtime.InteropServices;
+
+public class switch_serial_event_header_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal switch_serial_event_header_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(switch_serial_event_header_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~switch_serial_event_header_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if (swigCPtr.Handle != IntPtr.Zero) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          freeswitchPINVOKE.delete_switch_serial_event_header_t(swigCPtr);
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public string name {
+    set {
+      freeswitchPINVOKE.switch_serial_event_header_t_name_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_serial_event_header_t_name_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string value {
+    set {
+      freeswitchPINVOKE.switch_serial_event_header_t_value_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_serial_event_header_t_value_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_serial_event_header_t() : this(freeswitchPINVOKE.new_switch_serial_event_header_t(), true) {
+  }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 2.0.1
+ *
+ * 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_serial_event_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal switch_serial_event_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(switch_serial_event_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~switch_serial_event_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if (swigCPtr.Handle != IntPtr.Zero) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          freeswitchPINVOKE.delete_switch_serial_event_t(swigCPtr);
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public int event_id {
+    set {
+      freeswitchPINVOKE.switch_serial_event_t_event_id_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.switch_serial_event_t_event_id_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public int priority {
+    set {
+      freeswitchPINVOKE.switch_serial_event_t_priority_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.switch_serial_event_t_priority_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public int flags {
+    set {
+      freeswitchPINVOKE.switch_serial_event_t_flags_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.switch_serial_event_t_flags_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string owner {
+    set {
+      freeswitchPINVOKE.switch_serial_event_t_owner_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_serial_event_t_owner_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string subclass_name {
+    set {
+      freeswitchPINVOKE.switch_serial_event_t_subclass_name_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_serial_event_t_subclass_name_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string body {
+    set {
+      freeswitchPINVOKE.switch_serial_event_t_body_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_serial_event_t_body_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_serial_event_t() : this(freeswitchPINVOKE.new_switch_serial_event_t(), true) {
+  }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 2.0.1
+ *
+ * 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_session_ctl_t {
   SCSC_PAUSE_INBOUND,
   SCSC_PAUSE_OUTBOUND,