From 7c9885a045e57b3164fd366c7ee73986f6abc64a Mon Sep 17 00:00:00 2001
From: Anthony Minessale <anthm@freeswitch.org>
Date: Tue, 16 Apr 2013 08:51:29 -0500
Subject: [PATCH] swigall

---
 .../languages/mod_managed/freeswitch_wrap.cxx | 1251 ++++++++++++++++-
 src/mod/languages/mod_managed/managed/swig.cs | 1151 ++++++++++++++-
 2 files changed, 2296 insertions(+), 106 deletions(-)

diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.cxx
index a0dd415580..dd81abf181 100644
--- a/src/mod/languages/mod_managed/freeswitch_wrap.cxx
+++ b/src/mod/languages/mod_managed/freeswitch_wrap.cxx
@@ -1190,6 +1190,39 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_TRANSFER_SOURCE_VARIABLE_get() {
 }
 
 
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_SENSITIVE_DTMF_VARIABLE_get() {
+  char * jresult ;
+  char *result = 0 ;
+  
+  result = (char *) "sensitive_dtmf";
+  
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get() {
+  char * jresult ;
+  char *result = 0 ;
+  
+  result = (char *) "record_post_process_exec_app";
+  
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get() {
+  char * jresult ;
+  char *result = 0 ;
+  
+  result = (char *) "record_post_process_exec_api";
+  
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get() {
   char * jresult ;
   char *result = 0 ;
@@ -1278,6 +1311,28 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VAR
 }
 
 
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get() {
+  char * jresult ;
+  char *result = 0 ;
+  
+  result = (char *) "execute_on_pre_bridge";
+  
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get() {
+  char * jresult ;
+  char *result = 0 ;
+  
+  result = (char *) "execute_on_post_bridge";
+  
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get() {
   char * jresult ;
   char *result = 0 ;
@@ -1410,6 +1465,17 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_API_BRIDGE_END_VARIABLE_get() {
 }
 
 
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_API_BRIDGE_START_VARIABLE_get() {
+  char * jresult ;
+  char *result = 0 ;
+  
+  result = (char *) "api_before_bridge";
+  
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_API_HANGUP_HOOK_VARIABLE_get() {
   char * jresult ;
   char *result = 0 ;
@@ -2864,6 +2930,36 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_directories_lib_dir_get(void * jarg1
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_directories_certs_dir_set(void * jarg1, char * jarg2) {
+  switch_directories *arg1 = (switch_directories *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_directories *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->certs_dir) delete [] arg1->certs_dir;
+    if (arg2) {
+      arg1->certs_dir = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->certs_dir, (const char *)arg2);
+    } else {
+      arg1->certs_dir = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_directories_certs_dir_get(void * jarg1) {
+  char * jresult ;
+  switch_directories *arg1 = (switch_directories *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_directories *)jarg1; 
+  result = (char *) ((arg1)->certs_dir);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_directories() {
   void * jresult ;
   switch_directories *result = 0 ;
@@ -4472,6 +4568,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_t38_options_t(void * jarg1) {
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_MEDIA_TYPE_TOTAL_get() {
+  int jresult ;
+  int result;
+  
+  result = (int) 2;
+  
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_console_callback_match_node_val_set(void * jarg1, char * jarg2) {
   switch_console_callback_match_node *arg1 = (switch_console_callback_match_node *) 0 ;
   char *arg2 = (char *) 0 ;
@@ -6613,6 +6720,162 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_thread_data_t(void * jarg1) {
 }
 
 
+SWIGEXPORT char * SWIGSTDCALL CSharp_DTLS_SRTP_FNAME_get() {
+  char * jresult ;
+  char *result = 0 ;
+  
+  result = (char *) "dtls-srtp";
+  
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_MAX_FPLEN_get() {
+  int jresult ;
+  int result;
+  
+  result = (int) 64;
+  
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_MAX_FPSTRLEN_get() {
+  int jresult ;
+  int result;
+  
+  result = (int) 192;
+  
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_len_set(void * jarg1, unsigned long jarg2) {
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->len = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_dtls_fingerprint_t_len_get(void * jarg1) {
+  unsigned long jresult ;
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  result = (uint32_t) ((arg1)->len);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_data_set(void * jarg1, void * jarg2) {
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  uint8_t *arg2 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  arg2 = (uint8_t *)jarg2; 
+  {
+    size_t ii;
+    uint8_t *b = (uint8_t *) arg1->data;
+    for (ii = 0; ii < (size_t)64+1; ii++) b[ii] = *((uint8_t *) arg2 + ii);
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_dtls_fingerprint_t_data_get(void * jarg1) {
+  void * jresult ;
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  uint8_t *result = 0 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  result = (uint8_t *)(uint8_t *) ((arg1)->data);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_type_set(void * jarg1, char * jarg2) {
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->type) delete [] arg1->type;
+    if (arg2) {
+      arg1->type = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->type, (const char *)arg2);
+    } else {
+      arg1->type = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_dtls_fingerprint_t_type_get(void * jarg1) {
+  char * jresult ;
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  result = (char *) ((arg1)->type);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_str_set(void * jarg1, char * jarg2) {
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  char *arg2 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg2) strncpy((char *)arg1->str, (const char *)arg2, 192);
+    else arg1->str[0] = 0;
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_dtls_fingerprint_t_str_get(void * jarg1) {
+  char * jresult ;
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  result = (char *)(char *) ((arg1)->str);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_dtls_fingerprint_t() {
+  void * jresult ;
+  dtls_fingerprint_t *result = 0 ;
+  
+  result = (dtls_fingerprint_t *)new dtls_fingerprint_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_dtls_fingerprint_t(void * jarg1) {
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  delete arg1;
+  
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_MESSAGE_STRING_ARG_MAX_get() {
   int jresult ;
   int result;
@@ -7437,6 +7700,30 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_media_bug_get_write_replace_fra
 }
 
 
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_media_bug_get_native_read_frame(void * jarg1) {
+  void * jresult ;
+  switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
+  switch_frame_t *result = 0 ;
+  
+  arg1 = (switch_media_bug_t *)jarg1; 
+  result = (switch_frame_t *)switch_core_media_bug_get_native_read_frame(arg1);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_media_bug_get_native_write_frame(void * jarg1) {
+  void * jresult ;
+  switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
+  switch_frame_t *result = 0 ;
+  
+  arg1 = (switch_media_bug_t *)jarg1; 
+  result = (switch_frame_t *)switch_core_media_bug_get_native_write_frame(arg1);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_media_bug_set_write_replace_frame(void * jarg1, void * jarg2) {
   switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
   switch_frame_t *arg2 = (switch_frame_t *) 0 ;
@@ -7637,6 +7924,24 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_media_bug_transfer_recordings(void
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_media_bug_transfer_callback(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
+  int jresult ;
+  switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+  switch_core_session_t *arg2 = (switch_core_session_t *) 0 ;
+  switch_media_bug_callback_t arg3 = (switch_media_bug_callback_t) 0 ;
+  void *(*arg4)(switch_core_session_t *,void *) = (void *(*)(switch_core_session_t *,void *)) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_core_session_t *)jarg1; 
+  arg2 = (switch_core_session_t *)jarg2; 
+  arg3 = (switch_media_bug_callback_t)jarg3; 
+  arg4 = (void *(*)(switch_core_session_t *,void *))jarg4; 
+  result = (switch_status_t)switch_core_media_bug_transfer_callback(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_media_bug_read(void * jarg1, void * jarg2, int jarg3) {
   int jresult ;
   switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
@@ -8705,6 +9010,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_set_variable(char * jarg1, char *
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_get_variables(void * jarg1) {
+  int jresult ;
+  switch_event_t **arg1 = (switch_event_t **) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_event_t **)jarg1; 
+  result = (switch_status_t)switch_core_get_variables(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_set_var_conditional(char * jarg1, char * jarg2, char * jarg3) {
   int jresult ;
   char *arg1 = (char *) 0 ;
@@ -8769,6 +9086,16 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_findall_matching_var(ch
 }
 
 
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_findall() {
+  void * jresult ;
+  switch_console_callback_match_t *result = 0 ;
+  
+  result = (switch_console_callback_match_t *)switch_core_session_findall();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_session_hupall_endpoint(void * jarg1, int jarg2) {
   switch_endpoint_interface_t *arg1 = (switch_endpoint_interface_t *) 0 ;
   switch_call_cause_t arg2 ;
@@ -12316,6 +12643,20 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_default_ptime(char * jarg1, u
 }
 
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_default_rate(char * jarg1, unsigned long jarg2) {
+  unsigned long jresult ;
+  char *arg1 = (char *) 0 ;
+  uint32_t arg2 ;
+  uint32_t result;
+  
+  arg1 = (char *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  result = (uint32_t)switch_default_rate((char const *)arg1,arg2);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_add_registration(char * jarg1, char * jarg2, char * jarg3, char * jarg4, unsigned long jarg5, char * jarg6, char * jarg7, char * jarg8, char * jarg9) {
   int jresult ;
   char *arg1 = (char *) 0 ;
@@ -12728,6 +13069,58 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_fork() {
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_gen_certs(char * jarg1) {
+  int jresult ;
+  char *arg1 = (char *) 0 ;
+  int result;
+  
+  arg1 = (char *)jarg1; 
+  result = (int)switch_core_gen_certs((char const *)arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_cert_gen_fingerprint(char * jarg1, void * jarg2) {
+  int jresult ;
+  char *arg1 = (char *) 0 ;
+  dtls_fingerprint_t *arg2 = (dtls_fingerprint_t *) 0 ;
+  int result;
+  
+  arg1 = (char *)jarg1; 
+  arg2 = (dtls_fingerprint_t *)jarg2; 
+  result = (int)switch_core_cert_gen_fingerprint((char const *)arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_cert_expand_fingerprint(void * jarg1, char * jarg2) {
+  int jresult ;
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int result;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  result = (int)switch_core_cert_expand_fingerprint(arg1,(char const *)arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_cert_verify(void * jarg1) {
+  int jresult ;
+  dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+  int result;
+  
+  arg1 = (dtls_fingerprint_t *)jarg1; 
+  result = (int)switch_core_cert_verify(arg1);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_loadable_module_interface_module_name_set(void * jarg1, char * jarg2) {
   switch_loadable_module_interface *arg1 = (switch_loadable_module_interface *) 0 ;
   char *arg2 = (char *) 0 ;
@@ -14149,6 +14542,28 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_testv6_subnet(void * jarg1, void * jarg
 }
 
 
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_print_host(void * jarg1, char * jarg2, void * jarg3) {
+  char * jresult ;
+  switch_sockaddr_t *arg1 = (switch_sockaddr_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  switch_size_t arg3 ;
+  char *result = 0 ;
+  switch_size_t *argp3 ;
+  
+  arg1 = (switch_sockaddr_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  argp3 = (switch_size_t *)jarg3; 
+  if (!argp3) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_size_t", 0);
+    return 0;
+  }
+  arg3 = *argp3; 
+  result = (char *)switch_print_host(arg1,arg2,arg3);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_SMAX_get() {
   int jresult ;
   int result;
@@ -15135,6 +15550,19 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_string_match(char * jarg1, unsigned lon
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_strcasecmp_any(char * jarg1) {
+  int jresult ;
+  char *arg1 = (char *) 0 ;
+  void *arg2 = 0 ;
+  int result;
+  
+  arg1 = (char *)jarg1; 
+  result = (int)switch_strcasecmp_any((char const *)arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT char * SWIGSTDCALL CSharp_switch_util_quote_shell_arg(char * jarg1) {
   char * jresult ;
   char *arg1 = (char *) 0 ;
@@ -15757,6 +16185,64 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_caller_profile_caller_id_number_get(
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_name_set(void * jarg1, char * jarg2) {
+  switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_caller_profile *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg2) {
+      arg1->orig_caller_id_name = (char const *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->orig_caller_id_name, (const char *)arg2);
+    } else {
+      arg1->orig_caller_id_name = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_name_get(void * jarg1) {
+  char * jresult ;
+  switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_caller_profile *)jarg1; 
+  result = (char *) ((arg1)->orig_caller_id_name);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_number_set(void * jarg1, char * jarg2) {
+  switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (switch_caller_profile *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg2) {
+      arg1->orig_caller_id_number = (char const *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->orig_caller_id_number, (const char *)arg2);
+    } else {
+      arg1->orig_caller_id_number = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_number_get(void * jarg1) {
+  char * jresult ;
+  switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (switch_caller_profile *)jarg1; 
+  result = (char *) ((arg1)->orig_caller_id_number);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_callee_id_name_set(void * jarg1, char * jarg2) {
   switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
   char *arg2 = (char *) 0 ;
@@ -20844,6 +21330,52 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_file_handle_prefix_get(void * jarg1)
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_max_samples_set(void * jarg1, int jarg2) {
+  switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+  int arg2 ;
+  
+  arg1 = (switch_file_handle *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->max_samples = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_file_handle_max_samples_get(void * jarg1) {
+  int jresult ;
+  switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+  int result;
+  
+  arg1 = (switch_file_handle *)jarg1; 
+  result = (int) ((arg1)->max_samples);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_params_set(void * jarg1, void * jarg2) {
+  switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+  switch_event_t *arg2 = (switch_event_t *) 0 ;
+  
+  arg1 = (switch_file_handle *)jarg1; 
+  arg2 = (switch_event_t *)jarg2; 
+  if (arg1) (arg1)->params = arg2;
+  
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_file_handle_params_get(void * jarg1) {
+  void * jresult ;
+  switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+  switch_event_t *result = 0 ;
+  
+  arg1 = (switch_file_handle *)jarg1; 
+  result = (switch_event_t *) ((arg1)->params);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
 SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_file_handle() {
   void * jresult ;
   switch_file_handle *result = 0 ;
@@ -26663,6 +27195,14 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_caller_profile(void * jarg
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_step_caller_profile(void * jarg1) {
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  switch_channel_step_caller_profile(arg1);
+}
+
+
 SWIGEXPORT void * SWIGSTDCALL CSharp_switch_channel_get_caller_profile(void * jarg1) {
   void * jresult ;
   switch_channel_t *arg1 = (switch_channel_t *) 0 ;
@@ -26921,6 +27461,22 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_channel_del_variable_prefix(v
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_transfer_variable_prefix(void * jarg1, void * jarg2, char * jarg3) {
+  int jresult ;
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  switch_channel_t *arg2 = (switch_channel_t *) 0 ;
+  char *arg3 = (char *) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  arg2 = (switch_channel_t *)jarg2; 
+  arg3 = (char *)jarg3; 
+  result = (switch_status_t)switch_channel_transfer_variable_prefix(arg1,arg2,(char const *)arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_export_variable_var_check(void * jarg1, char * jarg2, char * jarg3, char * jarg4, int jarg5) {
   int jresult ;
   switch_channel_t *arg1 = (switch_channel_t *) 0 ;
@@ -27098,6 +27654,14 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_caller_extension(void * ja
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_invert_cid(void * jarg1) {
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  switch_channel_invert_cid(arg1);
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_flip_cid(void * jarg1) {
   switch_channel_t *arg1 = (switch_channel_t *) 0 ;
   
@@ -27106,13 +27670,11 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_flip_cid(void * jarg1) {
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_sort_cid(void * jarg1, int jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_sort_cid(void * jarg1) {
   switch_channel_t *arg1 = (switch_channel_t *) 0 ;
-  switch_bool_t arg2 ;
   
   arg1 = (switch_channel_t *)jarg1; 
-  arg2 = (switch_bool_t)jarg2; 
-  switch_channel_sort_cid(arg1,arg2);
+  switch_channel_sort_cid(arg1);
 }
 
 
@@ -28082,6 +28644,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_state_thread_unlock(void * jar
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_state_thread_trylock(void * jarg1) {
+  int jresult ;
+  switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_channel_t *)jarg1; 
+  result = (switch_status_t)switch_channel_state_thread_trylock(arg1);
+  jresult = 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 ;
@@ -31114,6 +31688,20 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_record_session(void * jarg1, char *
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_transfer_recordings(void * jarg1, void * jarg2) {
+  int jresult ;
+  switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+  switch_core_session_t *arg2 = (switch_core_session_t *) 0 ;
+  switch_status_t result;
+  
+  arg1 = (switch_core_session_t *)jarg1; 
+  arg2 = (switch_core_session_t *)jarg2; 
+  result = (switch_status_t)switch_ivr_transfer_recordings(arg1,arg2);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_eavesdrop_pop_eavesdropper(void * jarg1, void * jarg2) {
   int jresult ;
   switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
@@ -31768,6 +32356,22 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_hold_uuid(char * jarg1, char * jarg
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_hold_toggle_uuid(char * jarg1, char * jarg2, int jarg3) {
+  int jresult ;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  switch_bool_t arg3 ;
+  switch_status_t result;
+  
+  arg1 = (char *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (switch_bool_t)jarg3; 
+  result = (switch_status_t)switch_ivr_hold_toggle_uuid((char const *)arg1,(char const *)arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_unhold_uuid(char * jarg1) {
   int jresult ;
   char *arg1 = (char *) 0 ;
@@ -32902,6 +33506,22 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_blind_transfer_ack(void * jarg1, in
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_record_session_mask(void * jarg1, char * jarg2, int jarg3) {
+  int jresult ;
+  switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  switch_bool_t arg3 ;
+  switch_status_t result;
+  
+  arg1 = (switch_core_session_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (switch_bool_t)jarg3; 
+  result = (switch_status_t)switch_ivr_record_session_mask(arg1,(char const *)arg2,arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_RTP_MAX_BUF_LEN_get() {
   int jresult ;
   int result;
@@ -33122,6 +33742,521 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_rtp_crypto_key(void * jarg1) {
 }
 
 
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_foundation_set(void * jarg1, char * jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->foundation) delete [] arg1->foundation;
+    if (arg2) {
+      arg1->foundation = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->foundation, (const char *)arg2);
+    } else {
+      arg1->foundation = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_foundation_get(void * jarg1) {
+  char * jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (char *) ((arg1)->foundation);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_component_id_set(void * jarg1, int jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  int arg2 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->component_id = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_icand_t_component_id_get(void * jarg1) {
+  int jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  int result;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (int) ((arg1)->component_id);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_transport_set(void * jarg1, char * jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->transport) delete [] arg1->transport;
+    if (arg2) {
+      arg1->transport = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->transport, (const char *)arg2);
+    } else {
+      arg1->transport = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_transport_get(void * jarg1) {
+  char * jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (char *) ((arg1)->transport);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_priority_set(void * jarg1, unsigned long jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  uint32_t arg2 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (uint32_t)jarg2; 
+  if (arg1) (arg1)->priority = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_icand_t_priority_get(void * jarg1) {
+  unsigned long jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  uint32_t result;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (uint32_t) ((arg1)->priority);
+  jresult = (unsigned long)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_con_addr_set(void * jarg1, char * jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->con_addr) delete [] arg1->con_addr;
+    if (arg2) {
+      arg1->con_addr = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->con_addr, (const char *)arg2);
+    } else {
+      arg1->con_addr = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_con_addr_get(void * jarg1) {
+  char * jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (char *) ((arg1)->con_addr);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_con_port_set(void * jarg1, unsigned short jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  switch_port_t arg2 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (switch_port_t)jarg2; 
+  if (arg1) (arg1)->con_port = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_icand_t_con_port_get(void * jarg1) {
+  unsigned short jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  switch_port_t result;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (switch_port_t) ((arg1)->con_port);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_cand_type_set(void * jarg1, char * jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->cand_type) delete [] arg1->cand_type;
+    if (arg2) {
+      arg1->cand_type = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->cand_type, (const char *)arg2);
+    } else {
+      arg1->cand_type = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_cand_type_get(void * jarg1) {
+  char * jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (char *) ((arg1)->cand_type);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_raddr_set(void * jarg1, char * jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->raddr) delete [] arg1->raddr;
+    if (arg2) {
+      arg1->raddr = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->raddr, (const char *)arg2);
+    } else {
+      arg1->raddr = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_raddr_get(void * jarg1) {
+  char * jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (char *) ((arg1)->raddr);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_rport_set(void * jarg1, unsigned short jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  switch_port_t arg2 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (switch_port_t)jarg2; 
+  if (arg1) (arg1)->rport = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_icand_t_rport_get(void * jarg1) {
+  unsigned short jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  switch_port_t result;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (switch_port_t) ((arg1)->rport);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_generation_set(void * jarg1, char * jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->generation) delete [] arg1->generation;
+    if (arg2) {
+      arg1->generation = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->generation, (const char *)arg2);
+    } else {
+      arg1->generation = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_generation_get(void * jarg1) {
+  char * jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (char *) ((arg1)->generation);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_ready_set(void * jarg1, unsigned char jarg2) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  uint8_t arg2 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  arg2 = (uint8_t)jarg2; 
+  if (arg1) (arg1)->ready = arg2;
+  
+}
+
+
+SWIGEXPORT unsigned char SWIGSTDCALL CSharp_icand_t_ready_get(void * jarg1) {
+  unsigned char jresult ;
+  icand_t *arg1 = (icand_t *) 0 ;
+  uint8_t result;
+  
+  arg1 = (icand_t *)jarg1; 
+  result = (uint8_t) ((arg1)->ready);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_icand_t() {
+  void * jresult ;
+  icand_t *result = 0 ;
+  
+  result = (icand_t *)new icand_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_icand_t(void * jarg1) {
+  icand_t *arg1 = (icand_t *) 0 ;
+  
+  arg1 = (icand_t *)jarg1; 
+  delete arg1;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_MAX_CAND_get() {
+  int jresult ;
+  int result;
+  
+  result = (int) 25;
+  
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_cands_set(void * jarg1, void * jarg2) {
+  ice_t *arg1 = (ice_t *) 0 ;
+  icand_t (*arg2)[2] ;
+  
+  arg1 = (ice_t *)jarg1; 
+  arg2 = (icand_t (*)[2])jarg2; 
+  {
+    icand_t (*inp)[2] = (icand_t (*)[2])(arg2);
+    icand_t (*dest)[2] = (icand_t (*)[2])(arg1->cands);
+    size_t ii = 0;
+    for (; ii < 25; ++ii) {
+      icand_t *ip = inp[ii];
+      icand_t *dp = dest[ii];
+      size_t jj = 0;
+      for (; jj < 2; ++jj) dp[jj] = ip[jj];
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_ice_t_cands_get(void * jarg1) {
+  void * jresult ;
+  ice_t *arg1 = (ice_t *) 0 ;
+  icand_t (*result)[2] = 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  result = (icand_t (*)[2])(icand_t (*)[2]) ((arg1)->cands);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_cand_idx_set(void * jarg1, int jarg2) {
+  ice_t *arg1 = (ice_t *) 0 ;
+  int arg2 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  arg2 = (int)jarg2; 
+  if (arg1) (arg1)->cand_idx = arg2;
+  
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_ice_t_cand_idx_get(void * jarg1) {
+  int jresult ;
+  ice_t *arg1 = (ice_t *) 0 ;
+  int result;
+  
+  arg1 = (ice_t *)jarg1; 
+  result = (int) ((arg1)->cand_idx);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_chosen_set(void * jarg1, void * jarg2) {
+  ice_t *arg1 = (ice_t *) 0 ;
+  int *arg2 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  arg2 = (int *)jarg2; 
+  {
+    size_t ii;
+    int *b = (int *) arg1->chosen;
+    for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((int *) arg2 + ii);
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_ice_t_chosen_get(void * jarg1) {
+  void * jresult ;
+  ice_t *arg1 = (ice_t *) 0 ;
+  int *result = 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  result = (int *)(int *) ((arg1)->chosen);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_ufrag_set(void * jarg1, char * jarg2) {
+  ice_t *arg1 = (ice_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->ufrag) delete [] arg1->ufrag;
+    if (arg2) {
+      arg1->ufrag = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->ufrag, (const char *)arg2);
+    } else {
+      arg1->ufrag = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_ice_t_ufrag_get(void * jarg1) {
+  char * jresult ;
+  ice_t *arg1 = (ice_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  result = (char *) ((arg1)->ufrag);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_pwd_set(void * jarg1, char * jarg2) {
+  ice_t *arg1 = (ice_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->pwd) delete [] arg1->pwd;
+    if (arg2) {
+      arg1->pwd = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->pwd, (const char *)arg2);
+    } else {
+      arg1->pwd = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_ice_t_pwd_get(void * jarg1) {
+  char * jresult ;
+  ice_t *arg1 = (ice_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  result = (char *) ((arg1)->pwd);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_options_set(void * jarg1, char * jarg2) {
+  ice_t *arg1 = (ice_t *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  arg2 = (char *)jarg2; 
+  {
+    if (arg1->options) delete [] arg1->options;
+    if (arg2) {
+      arg1->options = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->options, (const char *)arg2);
+    } else {
+      arg1->options = 0;
+    }
+  }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_ice_t_options_get(void * jarg1) {
+  char * jresult ;
+  ice_t *arg1 = (ice_t *) 0 ;
+  char *result = 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  result = (char *) ((arg1)->options);
+  jresult = SWIG_csharp_string_callback((const char *)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_ice_t() {
+  void * jresult ;
+  ice_t *result = 0 ;
+  
+  result = (ice_t *)new ice_t();
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_ice_t(void * jarg1) {
+  ice_t *arg1 = (ice_t *) 0 ;
+  
+  arg1 = (ice_t *)jarg1; 
+  delete arg1;
+  
+}
+
+
 SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_add_crypto_key(void * jarg1, int jarg2, unsigned long jarg3, int jarg4, void * jarg5, void * jarg6) {
   int jresult ;
   switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
@@ -33265,13 +34400,13 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_change_interval(void * jarg1, unsig
 }
 
 
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, char * jarg6, void * jarg7, void * jarg8) {
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, char * jarg6, void * jarg7, void * jarg8) {
   int jresult ;
   switch_rtp_t **arg1 = (switch_rtp_t **) 0 ;
   switch_payload_t arg2 ;
   uint32_t arg3 ;
   uint32_t arg4 ;
-  switch_rtp_flag_t arg5 ;
+  switch_rtp_flag_t *arg5 ;
   char *arg6 = (char *) 0 ;
   char **arg7 = (char **) 0 ;
   switch_memory_pool_t *arg8 = (switch_memory_pool_t *) 0 ;
@@ -33281,7 +34416,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char
   arg2 = (switch_payload_t)jarg2; 
   arg3 = (uint32_t)jarg3; 
   arg4 = (uint32_t)jarg4; 
-  arg5 = (switch_rtp_flag_t)jarg5; 
+  arg5 = (switch_rtp_flag_t *)jarg5; 
   arg6 = (char *)jarg6; 
   arg7 = (char **)jarg7; 
   arg8 = (switch_memory_pool_t *)jarg8; 
@@ -33291,7 +34426,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char
 }
 
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short jarg2, char * jarg3, unsigned short jarg4, unsigned char jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8, char * jarg9, void * jarg10, void * jarg11) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short jarg2, char * jarg3, unsigned short jarg4, unsigned char jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8, char * jarg9, void * jarg10, void * jarg11) {
   void * jresult ;
   char *arg1 = (char *) 0 ;
   switch_port_t arg2 ;
@@ -33300,7 +34435,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short
   switch_payload_t arg5 ;
   uint32_t arg6 ;
   uint32_t arg7 ;
-  switch_rtp_flag_t arg8 ;
+  switch_rtp_flag_t *arg8 ;
   char *arg9 = (char *) 0 ;
   char **arg10 = (char **) 0 ;
   switch_memory_pool_t *arg11 = (switch_memory_pool_t *) 0 ;
@@ -33313,7 +34448,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short
   arg5 = (switch_payload_t)jarg5; 
   arg6 = (uint32_t)jarg6; 
   arg7 = (uint32_t)jarg7; 
-  arg8 = (switch_rtp_flag_t)jarg8; 
+  arg8 = (switch_rtp_flag_t *)jarg8; 
   arg9 = (char *)jarg9; 
   arg10 = (char **)jarg10; 
   arg11 = (switch_memory_pool_t *)jarg11; 
@@ -33461,53 +34596,51 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_destroy(void * jarg1) {
 }
 
 
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_ice(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_ice(void * jarg1, char * jarg2, char * jarg3, char * jarg4, char * jarg5, int jarg6, void * jarg7, void * jarg8) {
   int jresult ;
   switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  ice_proto_t arg6 ;
+  switch_core_media_ice_type_t arg7 ;
+  ice_t *arg8 = (ice_t *) 0 ;
   switch_status_t result;
+  switch_core_media_ice_type_t *argp7 ;
   
   arg1 = (switch_rtp_t *)jarg1; 
   arg2 = (char *)jarg2; 
   arg3 = (char *)jarg3; 
   arg4 = (char *)jarg4; 
-  result = (switch_status_t)switch_rtp_activate_ice(arg1,arg2,arg3,(char const *)arg4);
+  arg5 = (char *)jarg5; 
+  arg6 = (ice_proto_t)jarg6; 
+  argp7 = (switch_core_media_ice_type_t *)jarg7; 
+  if (!argp7) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_core_media_ice_type_t", 0);
+    return 0;
+  }
+  arg7 = *argp7; 
+  arg8 = (ice_t *)jarg8; 
+  result = (switch_status_t)switch_rtp_activate_ice(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,arg6,arg7,arg8);
   jresult = result; 
   return jresult;
 }
 
 
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_rtcp_ice(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
-  int jresult ;
-  switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
-  char *arg2 = (char *) 0 ;
-  char *arg3 = (char *) 0 ;
-  char *arg4 = (char *) 0 ;
-  switch_status_t result;
-  
-  arg1 = (switch_rtp_t *)jarg1; 
-  arg2 = (char *)jarg2; 
-  arg3 = (char *)jarg3; 
-  arg4 = (char *)jarg4; 
-  result = (switch_status_t)switch_rtp_activate_rtcp_ice(arg1,arg2,arg3,(char const *)arg4);
-  jresult = result; 
-  return jresult;
-}
-
-
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_rtcp(void * jarg1, int jarg2, unsigned short jarg3) {
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_rtcp(void * jarg1, int jarg2, unsigned short jarg3, int jarg4) {
   int jresult ;
   switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
   int arg2 ;
   switch_port_t arg3 ;
+  switch_bool_t arg4 ;
   switch_status_t result;
   
   arg1 = (switch_rtp_t *)jarg1; 
   arg2 = (int)jarg2; 
   arg3 = (switch_port_t)jarg3; 
-  result = (switch_status_t)switch_rtp_activate_rtcp(arg1,arg2,arg3);
+  arg4 = (switch_bool_t)jarg4; 
+  result = (switch_status_t)switch_rtp_activate_rtcp(arg1,arg2,arg3,arg4);
   jresult = result; 
   return jresult;
 }
@@ -33587,7 +34720,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_get_jitter_buffer(void * jarg1)
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flag(void * jarg1, unsigned long jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flag(void * jarg1, int jarg2) {
   switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
   switch_rtp_flag_t arg2 ;
   
@@ -33597,7 +34730,27 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flag(void * jarg1, unsigned lo
 }
 
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtp_test_flag(void * jarg1, unsigned long jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flags(void * jarg1, void * jarg2) {
+  switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
+  switch_rtp_flag_t *arg2 ;
+  
+  arg1 = (switch_rtp_t *)jarg1; 
+  arg2 = (switch_rtp_flag_t *)jarg2; 
+  switch_rtp_set_flags(arg1,arg2);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_clear_flags(void * jarg1, void * jarg2) {
+  switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
+  switch_rtp_flag_t *arg2 ;
+  
+  arg1 = (switch_rtp_t *)jarg1; 
+  arg2 = (switch_rtp_flag_t *)jarg2; 
+  switch_rtp_clear_flags(arg1,arg2);
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtp_test_flag(void * jarg1, int jarg2) {
   unsigned long jresult ;
   switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
   switch_rtp_flag_t arg2 ;
@@ -33611,7 +34764,7 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtp_test_flag(void * jarg1, u
 }
 
 
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_clear_flag(void * jarg1, unsigned long jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_clear_flag(void * jarg1, int jarg2) {
   switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
   switch_rtp_flag_t arg2 ;
   
@@ -34031,6 +35184,34 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_interdigit_delay(void * jarg1,
 }
 
 
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_add_dtls(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
+  int jresult ;
+  switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
+  dtls_fingerprint_t *arg2 = (dtls_fingerprint_t *) 0 ;
+  dtls_fingerprint_t *arg3 = (dtls_fingerprint_t *) 0 ;
+  dtls_type_t arg4 ;
+  switch_status_t result;
+  
+  arg1 = (switch_rtp_t *)jarg1; 
+  arg2 = (dtls_fingerprint_t *)jarg2; 
+  arg3 = (dtls_fingerprint_t *)jarg3; 
+  arg4 = (dtls_type_t)jarg4; 
+  result = (switch_status_t)switch_rtp_add_dtls(arg1,arg2,arg3,arg4);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_has_dtls() {
+  int jresult ;
+  int result;
+  
+  result = (int)switch_rtp_has_dtls();
+  jresult = result; 
+  return jresult;
+}
+
+
 SWIGEXPORT void SWIGSTDCALL CSharp_switch_log_node_t_data_set(void * jarg1, char * jarg2) {
   switch_log_node_t *arg1 = (switch_log_node_t *) 0 ;
   char *arg2 = (char *) 0 ;
diff --git a/src/mod/languages/mod_managed/managed/swig.cs b/src/mod/languages/mod_managed/managed/swig.cs
index 4aba6331e2..81a9e258fc 100644
--- a/src/mod/languages/mod_managed/managed/swig.cs
+++ b/src/mod/languages/mod_managed/managed/swig.cs
@@ -531,6 +531,131 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class dtls_fingerprint_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal dtls_fingerprint_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(dtls_fingerprint_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~dtls_fingerprint_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_dtls_fingerprint_t(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public uint len {
+    set {
+      freeswitchPINVOKE.dtls_fingerprint_t_len_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.dtls_fingerprint_t_len_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_unsigned_char data {
+    set {
+      freeswitchPINVOKE.dtls_fingerprint_t_data_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.dtls_fingerprint_t_data_get(swigCPtr);
+      SWIGTYPE_p_unsigned_char ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public string type {
+    set {
+      freeswitchPINVOKE.dtls_fingerprint_t_type_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.dtls_fingerprint_t_type_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string str {
+    set {
+      freeswitchPINVOKE.dtls_fingerprint_t_str_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.dtls_fingerprint_t_str_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public dtls_fingerprint_t() : this(freeswitchPINVOKE.new_dtls_fingerprint_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 dtls_state_t {
+  DS_HANDSHAKE,
+  DS_SETUP,
+  DS_READY,
+  DS_FAIL,
+  DS_INVALID
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * 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 dtls_type_t {
+  DTLS_TYPE_CLIENT = (1 << 0),
+  DTLS_TYPE_SERVER = (1 << 1),
+  DTLS_TYPE_RTP = (1 << 2),
+  DTLS_TYPE_RTCP = (1 << 3)
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * 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 DTMF : IDisposable {
   private HandleRef swigCPtr;
   protected bool swigCMemOwn;
@@ -596,7 +721,8 @@ public class DTMF : IDisposable {
 namespace FreeSWITCH.Native {
 
 public enum dtmf_flag_t {
-  DTMF_FLAG_SKIP_PROCESS = (1 << 0)
+  DTMF_FLAG_SKIP_PROCESS = (1 << 0),
+  DTMF_FLAG_SENSITIVE = (1 << 1)
 }
 
 }
@@ -1116,6 +1242,18 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_frame switch_core_media_bug_get_native_read_frame(SWIGTYPE_p_switch_media_bug bug) {
+    IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_native_read_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug));
+    switch_frame ret = (cPtr == IntPtr.Zero) ? null : new switch_frame(cPtr, false);
+    return ret;
+  }
+
+  public static switch_frame switch_core_media_bug_get_native_write_frame(SWIGTYPE_p_switch_media_bug bug) {
+    IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_native_write_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug));
+    switch_frame ret = (cPtr == IntPtr.Zero) ? null : new switch_frame(cPtr, false);
+    return ret;
+  }
+
   public static void switch_core_media_bug_set_write_replace_frame(SWIGTYPE_p_switch_media_bug bug, switch_frame frame) {
     freeswitchPINVOKE.switch_core_media_bug_set_write_replace_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug), switch_frame.getCPtr(frame));
   }
@@ -1195,6 +1333,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_status_t switch_core_media_bug_transfer_callback(SWIGTYPE_p_switch_core_session orig_session, SWIGTYPE_p_switch_core_session new_session, SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t callback, SWIGTYPE_p_f_p_switch_core_session_p_void__p_void user_data_dup_func) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_transfer_callback(SWIGTYPE_p_switch_core_session.getCPtr(orig_session), SWIGTYPE_p_switch_core_session.getCPtr(new_session), SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t.getCPtr(callback), SWIGTYPE_p_f_p_switch_core_session_p_void__p_void.getCPtr(user_data_dup_func));
+    return ret;
+  }
+
   public static switch_status_t switch_core_media_bug_read(SWIGTYPE_p_switch_media_bug bug, switch_frame frame, switch_bool_t fill) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_read(SWIGTYPE_p_switch_media_bug.getCPtr(bug), switch_frame.getCPtr(frame), (int)fill);
     return ret;
@@ -1605,6 +1748,11 @@ public class freeswitch {
     freeswitchPINVOKE.switch_core_set_variable(varname, value);
   }
 
+  public static switch_status_t switch_core_get_variables(SWIGTYPE_p_p_switch_event arg0) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_get_variables(SWIGTYPE_p_p_switch_event.getCPtr(arg0));
+    return ret;
+  }
+
   public static switch_bool_t switch_core_set_var_conditional(string varname, string value, string val2) {
     switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_core_set_var_conditional(varname, value, val2);
     return ret;
@@ -1629,6 +1777,12 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_console_callback_match switch_core_session_findall() {
+    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_findall();
+    switch_console_callback_match ret = (cPtr == IntPtr.Zero) ? null : new switch_console_callback_match(cPtr, false);
+    return ret;
+  }
+
   public static void switch_core_session_hupall_endpoint(switch_endpoint_interface endpoint_interface, switch_call_cause_t cause) {
     freeswitchPINVOKE.switch_core_session_hupall_endpoint(switch_endpoint_interface.getCPtr(endpoint_interface), (int)cause);
   }
@@ -2773,6 +2927,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static uint switch_default_rate(string name, uint number) {
+    uint ret = freeswitchPINVOKE.switch_default_rate(name, number);
+    return ret;
+  }
+
   public static switch_status_t switch_core_add_registration(string user, string realm, string token, string url, uint expires, string network_ip, string network_port, string network_proto, string metadata) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_add_registration(user, realm, token, url, expires, network_ip, network_port, network_proto, metadata);
     return ret;
@@ -2918,6 +3077,26 @@ public class freeswitch {
     return ret;
   }
 
+  public static int switch_core_gen_certs(string prefix) {
+    int ret = freeswitchPINVOKE.switch_core_gen_certs(prefix);
+    return ret;
+  }
+
+  public static int switch_core_cert_gen_fingerprint(string prefix, dtls_fingerprint_t fp) {
+    int ret = freeswitchPINVOKE.switch_core_cert_gen_fingerprint(prefix, dtls_fingerprint_t.getCPtr(fp));
+    return ret;
+  }
+
+  public static int switch_core_cert_expand_fingerprint(dtls_fingerprint_t fp, string str) {
+    int ret = freeswitchPINVOKE.switch_core_cert_expand_fingerprint(dtls_fingerprint_t.getCPtr(fp), str);
+    return ret;
+  }
+
+  public static int switch_core_cert_verify(dtls_fingerprint_t fp) {
+    int ret = freeswitchPINVOKE.switch_core_cert_verify(dtls_fingerprint_t.getCPtr(fp));
+    return ret;
+  }
+
   public static switch_status_t switch_loadable_module_init(switch_bool_t autoload) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_loadable_module_init((int)autoload);
     return ret;
@@ -3251,6 +3430,12 @@ public class freeswitch {
     return ret;
   }
 
+  public static string switch_print_host(SWIGTYPE_p_switch_sockaddr_t addr, string buf, SWIGTYPE_p_switch_size_t len) {
+    string ret = freeswitchPINVOKE.switch_print_host(SWIGTYPE_p_switch_sockaddr_t.getCPtr(addr), buf, SWIGTYPE_p_switch_size_t.getCPtr(len));
+    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+    return ret;
+  }
+
   public static int _zstr(string s) {
     int ret = freeswitchPINVOKE._zstr(s);
     return ret;
@@ -3572,6 +3757,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static int switch_strcasecmp_any(string str) {
+    int ret = freeswitchPINVOKE.switch_strcasecmp_any(str);
+    return ret;
+  }
+
   public static string switch_util_quote_shell_arg(string arg0) {
     string ret = freeswitchPINVOKE.switch_util_quote_shell_arg(arg0);
     return ret;
@@ -3851,6 +4041,10 @@ public class freeswitch {
     freeswitchPINVOKE.switch_channel_set_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_profile.getCPtr(caller_profile));
   }
 
+  public static void switch_channel_step_caller_profile(SWIGTYPE_p_switch_channel channel) {
+    freeswitchPINVOKE.switch_channel_step_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel));
+  }
+
   public static switch_caller_profile switch_channel_get_caller_profile(SWIGTYPE_p_switch_channel channel) {
     IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel));
     switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
@@ -3946,6 +4140,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_status_t switch_channel_transfer_variable_prefix(SWIGTYPE_p_switch_channel orig_channel, SWIGTYPE_p_switch_channel new_channel, string prefix) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_transfer_variable_prefix(SWIGTYPE_p_switch_channel.getCPtr(orig_channel), SWIGTYPE_p_switch_channel.getCPtr(new_channel), prefix);
+    return ret;
+  }
+
   public static switch_status_t switch_channel_export_variable_var_check(SWIGTYPE_p_switch_channel channel, string varname, string val, string export_varname, switch_bool_t var_check) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_export_variable_var_check(SWIGTYPE_p_switch_channel.getCPtr(channel), varname, val, export_varname, (int)var_check);
     return ret;
@@ -4007,12 +4206,16 @@ public class freeswitch {
     freeswitchPINVOKE.switch_channel_set_caller_extension(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_extension.getCPtr(caller_extension));
   }
 
+  public static void switch_channel_invert_cid(SWIGTYPE_p_switch_channel channel) {
+    freeswitchPINVOKE.switch_channel_invert_cid(SWIGTYPE_p_switch_channel.getCPtr(channel));
+  }
+
   public static void switch_channel_flip_cid(SWIGTYPE_p_switch_channel channel) {
     freeswitchPINVOKE.switch_channel_flip_cid(SWIGTYPE_p_switch_channel.getCPtr(channel));
   }
 
-  public static void switch_channel_sort_cid(SWIGTYPE_p_switch_channel channel, switch_bool_t arg1) {
-    freeswitchPINVOKE.switch_channel_sort_cid(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)arg1);
+  public static void switch_channel_sort_cid(SWIGTYPE_p_switch_channel channel) {
+    freeswitchPINVOKE.switch_channel_sort_cid(SWIGTYPE_p_switch_channel.getCPtr(channel));
   }
 
   public static switch_caller_extension switch_channel_get_caller_extension(SWIGTYPE_p_switch_channel channel) {
@@ -4372,6 +4575,11 @@ public class freeswitch {
     freeswitchPINVOKE.switch_channel_state_thread_unlock(SWIGTYPE_p_switch_channel.getCPtr(channel));
   }
 
+  public static switch_status_t switch_channel_state_thread_trylock(SWIGTYPE_p_switch_channel channel) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_state_thread_trylock(SWIGTYPE_p_switch_channel.getCPtr(channel));
+    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();
@@ -4898,6 +5106,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_status_t switch_ivr_transfer_recordings(SWIGTYPE_p_switch_core_session orig_session, SWIGTYPE_p_switch_core_session new_session) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_transfer_recordings(SWIGTYPE_p_switch_core_session.getCPtr(orig_session), SWIGTYPE_p_switch_core_session.getCPtr(new_session));
+    return ret;
+  }
+
   public static switch_status_t switch_ivr_eavesdrop_pop_eavesdropper(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_core_session sessionp) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_eavesdrop_pop_eavesdropper(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_core_session.getCPtr(sessionp));
     return ret;
@@ -5079,6 +5292,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_status_t switch_ivr_hold_toggle_uuid(string uuid, string message, switch_bool_t moh) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_hold_toggle_uuid(uuid, message, (int)moh);
+    return ret;
+  }
+
   public static switch_status_t switch_ivr_unhold_uuid(string uuid) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_unhold_uuid(uuid);
     return ret;
@@ -5440,6 +5658,11 @@ public class freeswitch {
     return ret;
   }
 
+  public static switch_status_t switch_ivr_record_session_mask(SWIGTYPE_p_switch_core_session session, string file, switch_bool_t on) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_record_session_mask(SWIGTYPE_p_switch_core_session.getCPtr(session), file, (int)on);
+    return ret;
+  }
+
   public static switch_status_t switch_rtp_add_crypto_key(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_crypto_direction_t direction, uint index, switch_rtp_crypto_key_type_t type, SWIGTYPE_p_unsigned_char key, SWIGTYPE_p_switch_size_t keylen) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_add_crypto_key(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)direction, index, (int)type, SWIGTYPE_p_unsigned_char.getCPtr(key), SWIGTYPE_p_switch_size_t.getCPtr(keylen));
     if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
@@ -5492,13 +5715,13 @@ public class freeswitch {
     return ret;
   }
 
-  public static switch_status_t switch_rtp_create(SWIGTYPE_p_p_switch_rtp new_rtp_session, byte payload, uint samples_per_interval, uint ms_per_packet, uint flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
-    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_create(SWIGTYPE_p_p_switch_rtp.getCPtr(new_rtp_session), payload, samples_per_interval, ms_per_packet, flags, timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
+  public static switch_status_t switch_rtp_create(SWIGTYPE_p_p_switch_rtp new_rtp_session, byte payload, uint samples_per_interval, uint ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_create(SWIGTYPE_p_p_switch_rtp.getCPtr(new_rtp_session), payload, samples_per_interval, ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags), timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
     return ret;
   }
 
-  public static SWIGTYPE_p_switch_rtp switch_rtp_new(string rx_host, ushort rx_port, string tx_host, ushort tx_port, byte payload, uint samples_per_interval, uint ms_per_packet, uint flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
-    IntPtr cPtr = freeswitchPINVOKE.switch_rtp_new(rx_host, rx_port, tx_host, tx_port, payload, samples_per_interval, ms_per_packet, flags, timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
+  public static SWIGTYPE_p_switch_rtp switch_rtp_new(string rx_host, ushort rx_port, string tx_host, ushort tx_port, byte payload, uint samples_per_interval, uint ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
+    IntPtr cPtr = freeswitchPINVOKE.switch_rtp_new(rx_host, rx_port, tx_host, tx_port, payload, samples_per_interval, ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags), timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
     SWIGTYPE_p_switch_rtp ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_rtp(cPtr, false);
     return ret;
   }
@@ -5557,18 +5780,14 @@ public class freeswitch {
     freeswitchPINVOKE.switch_rtp_destroy(SWIGTYPE_p_p_switch_rtp.getCPtr(rtp_session));
   }
 
-  public static switch_status_t switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp rtp_session, string login, string rlogin, string password) {
-    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), login, rlogin, password);
+  public static switch_status_t switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp rtp_session, string login, string rlogin, string password, string rpassword, ice_proto_t proto, SWIGTYPE_p_switch_core_media_ice_type_t type, ice_t ice_params) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), login, rlogin, password, rpassword, (int)proto, SWIGTYPE_p_switch_core_media_ice_type_t.getCPtr(type), ice_t.getCPtr(ice_params));
+    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
-  public static switch_status_t switch_rtp_activate_rtcp_ice(SWIGTYPE_p_switch_rtp rtp_session, string login, string rlogin, string password) {
-    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_rtcp_ice(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), login, rlogin, password);
-    return ret;
-  }
-
-  public static switch_status_t switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp rtp_session, int send_rate, ushort remote_port) {
-    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), send_rate, remote_port);
+  public static switch_status_t switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp rtp_session, int send_rate, ushort remote_port, switch_bool_t mux) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), send_rate, remote_port, (int)mux);
     return ret;
   }
 
@@ -5598,17 +5817,25 @@ public class freeswitch {
     return ret;
   }
 
-  public static void switch_rtp_set_flag(SWIGTYPE_p_switch_rtp rtp_session, uint flags) {
-    freeswitchPINVOKE.switch_rtp_set_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), flags);
+  public static void switch_rtp_set_flag(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_flag_t flag) {
+    freeswitchPINVOKE.switch_rtp_set_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)flag);
   }
 
-  public static uint switch_rtp_test_flag(SWIGTYPE_p_switch_rtp rtp_session, uint flags) {
-    uint ret = freeswitchPINVOKE.switch_rtp_test_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), flags);
+  public static void switch_rtp_set_flags(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_switch_rtp_flag_t flags) {
+    freeswitchPINVOKE.switch_rtp_set_flags(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags));
+  }
+
+  public static void switch_rtp_clear_flags(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_switch_rtp_flag_t flags) {
+    freeswitchPINVOKE.switch_rtp_clear_flags(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags));
+  }
+
+  public static uint switch_rtp_test_flag(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_flag_t flags) {
+    uint ret = freeswitchPINVOKE.switch_rtp_test_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)flags);
     return ret;
   }
 
-  public static void switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp rtp_session, uint flags) {
-    freeswitchPINVOKE.switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), flags);
+  public static void switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_flag_t flag) {
+    freeswitchPINVOKE.switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)flag);
   }
 
   public static SWIGTYPE_p_switch_socket_t switch_rtp_get_rtp_socket(SWIGTYPE_p_switch_rtp rtp_session) {
@@ -5758,6 +5985,16 @@ public class freeswitch {
     freeswitchPINVOKE.switch_rtp_set_interdigit_delay(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), delay);
   }
 
+  public static switch_status_t switch_rtp_add_dtls(SWIGTYPE_p_switch_rtp rtp_session, dtls_fingerprint_t local_fp, dtls_fingerprint_t remote_fp, dtls_type_t type) {
+    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_add_dtls(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), dtls_fingerprint_t.getCPtr(local_fp), dtls_fingerprint_t.getCPtr(remote_fp), (int)type);
+    return ret;
+  }
+
+  public static int switch_rtp_has_dtls() {
+    int ret = freeswitchPINVOKE.switch_rtp_has_dtls();
+    return ret;
+  }
+
   public static switch_status_t switch_log_init(SWIGTYPE_p_apr_pool_t pool, switch_bool_t colorize) {
     switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_log_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool), (int)colorize);
     return ret;
@@ -6382,6 +6619,9 @@ public class freeswitch {
   public static readonly string SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE = freeswitchPINVOKE.SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE_get();
   public static readonly string SWITCH_TRANSFER_HISTORY_VARIABLE = freeswitchPINVOKE.SWITCH_TRANSFER_HISTORY_VARIABLE_get();
   public static readonly string SWITCH_TRANSFER_SOURCE_VARIABLE = freeswitchPINVOKE.SWITCH_TRANSFER_SOURCE_VARIABLE_get();
+  public static readonly string SWITCH_SENSITIVE_DTMF_VARIABLE = freeswitchPINVOKE.SWITCH_SENSITIVE_DTMF_VARIABLE_get();
+  public static readonly string SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE = freeswitchPINVOKE.SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get();
+  public static readonly string SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE = freeswitchPINVOKE.SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE_get();
@@ -6390,6 +6630,8 @@ public class freeswitch {
   public static readonly string SWITCH_CHANNEL_EXECUTE_ON_ORIGINATE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_ORIGINATE_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE_get();
+  public static readonly string SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get();
+  public static readonly string SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE_get();
   public static readonly string SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE_get();
@@ -6402,6 +6644,7 @@ public class freeswitch {
   public static readonly string SWITCH_HOLDING_UUID_VARIABLE = freeswitchPINVOKE.SWITCH_HOLDING_UUID_VARIABLE_get();
   public static readonly string SWITCH_SOFT_HOLDING_UUID_VARIABLE = freeswitchPINVOKE.SWITCH_SOFT_HOLDING_UUID_VARIABLE_get();
   public static readonly string SWITCH_API_BRIDGE_END_VARIABLE = freeswitchPINVOKE.SWITCH_API_BRIDGE_END_VARIABLE_get();
+  public static readonly string SWITCH_API_BRIDGE_START_VARIABLE = freeswitchPINVOKE.SWITCH_API_BRIDGE_START_VARIABLE_get();
   public static readonly string SWITCH_API_HANGUP_HOOK_VARIABLE = freeswitchPINVOKE.SWITCH_API_HANGUP_HOOK_VARIABLE_get();
   public static readonly string SWITCH_API_REPORTING_HOOK_VARIABLE = freeswitchPINVOKE.SWITCH_API_REPORTING_HOOK_VARIABLE_get();
   public static readonly string SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE = freeswitchPINVOKE.SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE_get();
@@ -6470,6 +6713,7 @@ public class freeswitch {
   public static readonly int SWITCH_CORE_QUEUE_LEN = freeswitchPINVOKE.SWITCH_CORE_QUEUE_LEN_get();
   public static readonly int SWITCH_MAX_MANAGEMENT_BUFFER_LEN = freeswitchPINVOKE.SWITCH_MAX_MANAGEMENT_BUFFER_LEN_get();
   public static readonly int SWITCH_RTP_CNG_PAYLOAD = freeswitchPINVOKE.SWITCH_RTP_CNG_PAYLOAD_get();
+  public static readonly int SWITCH_MEDIA_TYPE_TOTAL = freeswitchPINVOKE.SWITCH_MEDIA_TYPE_TOTAL_get();
   public static readonly int DMACHINE_MAX_DIGIT_LEN = freeswitchPINVOKE.DMACHINE_MAX_DIGIT_LEN_get();
   public static readonly int MAX_ARG_RECURSION = freeswitchPINVOKE.MAX_ARG_RECURSION_get();
   public static readonly int SWITCH_API_VERSION = freeswitchPINVOKE.SWITCH_API_VERSION_get();
@@ -6504,6 +6748,9 @@ public class freeswitch {
   public static readonly int SWITCH_CORE_DB_DONE = freeswitchPINVOKE.SWITCH_CORE_DB_DONE_get();
   public static readonly int SWITCH_MAX_CORE_THREAD_SESSION_OBJS = freeswitchPINVOKE.SWITCH_MAX_CORE_THREAD_SESSION_OBJS_get();
   public static readonly int SWITCH_MAX_STREAMS = freeswitchPINVOKE.SWITCH_MAX_STREAMS_get();
+  public static readonly string DTLS_SRTP_FNAME = freeswitchPINVOKE.DTLS_SRTP_FNAME_get();
+  public static readonly int MAX_FPLEN = freeswitchPINVOKE.MAX_FPLEN_get();
+  public static readonly int MAX_FPSTRLEN = freeswitchPINVOKE.MAX_FPSTRLEN_get();
   public static readonly int MESSAGE_STRING_ARG_MAX = freeswitchPINVOKE.MESSAGE_STRING_ARG_MAX_get();
   public static readonly int CACHE_DB_LEN = freeswitchPINVOKE.CACHE_DB_LEN_get();
   public static readonly int SWITCH_CMD_CHUNK_LEN = freeswitchPINVOKE.SWITCH_CMD_CHUNK_LEN_get();
@@ -6517,6 +6764,7 @@ public class freeswitch {
   public static readonly int SWITCH_RTP_KEY_LEN = freeswitchPINVOKE.SWITCH_RTP_KEY_LEN_get();
   public static readonly string SWITCH_RTP_CRYPTO_KEY_32 = freeswitchPINVOKE.SWITCH_RTP_CRYPTO_KEY_32_get();
   public static readonly string SWITCH_RTP_CRYPTO_KEY_80 = freeswitchPINVOKE.SWITCH_RTP_CRYPTO_KEY_80_get();
+  public static readonly int MAX_CAND = freeswitchPINVOKE.MAX_CAND_get();
   public static readonly int SWITCH_XML_BUFSIZE = freeswitchPINVOKE.SWITCH_XML_BUFSIZE_get();
 }
 
@@ -6952,6 +7200,15 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_TRANSFER_SOURCE_VARIABLE_get")]
   public static extern string SWITCH_TRANSFER_SOURCE_VARIABLE_get();
 
+  [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_SENSITIVE_DTMF_VARIABLE_get")]
+  public static extern string SWITCH_SENSITIVE_DTMF_VARIABLE_get();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get")]
+  public static extern string SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get")]
+  public static extern string SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get();
+
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get")]
   public static extern string SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get();
 
@@ -6976,6 +7233,12 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE_get")]
   public static extern string SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE_get();
 
+  [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get")]
+  public static extern string SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get")]
+  public static extern string SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get();
+
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get")]
   public static extern string SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get();
 
@@ -7012,6 +7275,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_API_BRIDGE_END_VARIABLE_get")]
   public static extern string SWITCH_API_BRIDGE_END_VARIABLE_get();
 
+  [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_API_BRIDGE_START_VARIABLE_get")]
+  public static extern string SWITCH_API_BRIDGE_START_VARIABLE_get();
+
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_API_HANGUP_HOOK_VARIABLE_get")]
   public static extern string SWITCH_API_HANGUP_HOOK_VARIABLE_get();
 
@@ -7375,6 +7641,12 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_directories_lib_dir_get")]
   public static extern string switch_directories_lib_dir_get(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_directories_certs_dir_set")]
+  public static extern void switch_directories_certs_dir_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_directories_certs_dir_get")]
+  public static extern string switch_directories_certs_dir_get(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_new_switch_directories")]
   public static extern IntPtr new_switch_directories();
 
@@ -7780,6 +8052,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_t38_options_t")]
   public static extern void delete_switch_t38_options_t(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_MEDIA_TYPE_TOTAL_get")]
+  public static extern int SWITCH_MEDIA_TYPE_TOTAL_get();
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_console_callback_match_node_val_set")]
   public static extern void switch_console_callback_match_node_val_set(HandleRef jarg1, string jarg2);
 
@@ -8308,6 +8583,45 @@ class freeswitchPINVOKE {
   [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_DTLS_SRTP_FNAME_get")]
+  public static extern string DTLS_SRTP_FNAME_get();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_MAX_FPLEN_get")]
+  public static extern int MAX_FPLEN_get();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_MAX_FPSTRLEN_get")]
+  public static extern int MAX_FPSTRLEN_get();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_len_set")]
+  public static extern void dtls_fingerprint_t_len_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_len_get")]
+  public static extern uint dtls_fingerprint_t_len_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_data_set")]
+  public static extern void dtls_fingerprint_t_data_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_data_get")]
+  public static extern IntPtr dtls_fingerprint_t_data_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_type_set")]
+  public static extern void dtls_fingerprint_t_type_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_type_get")]
+  public static extern string dtls_fingerprint_t_type_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_str_set")]
+  public static extern void dtls_fingerprint_t_str_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_str_get")]
+  public static extern string dtls_fingerprint_t_str_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_dtls_fingerprint_t")]
+  public static extern IntPtr new_dtls_fingerprint_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_dtls_fingerprint_t")]
+  public static extern void delete_dtls_fingerprint_t(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_MESSAGE_STRING_ARG_MAX_get")]
   public static extern int MESSAGE_STRING_ARG_MAX_get();
 
@@ -8503,6 +8817,12 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_get_write_replace_frame")]
   public static extern IntPtr switch_core_media_bug_get_write_replace_frame(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_get_native_read_frame")]
+  public static extern IntPtr switch_core_media_bug_get_native_read_frame(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_get_native_write_frame")]
+  public static extern IntPtr switch_core_media_bug_get_native_write_frame(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_set_write_replace_frame")]
   public static extern void switch_core_media_bug_set_write_replace_frame(HandleRef jarg1, HandleRef jarg2);
 
@@ -8551,6 +8871,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_transfer_recordings")]
   public static extern int switch_core_media_bug_transfer_recordings(HandleRef jarg1, HandleRef jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_transfer_callback")]
+  public static extern int switch_core_media_bug_transfer_callback(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, HandleRef jarg4);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_read")]
   public static extern int switch_core_media_bug_read(HandleRef jarg1, HandleRef jarg2, int jarg3);
 
@@ -8797,6 +9120,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_set_variable")]
   public static extern void switch_core_set_variable(string jarg1, string jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_get_variables")]
+  public static extern int switch_core_get_variables(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_set_var_conditional")]
   public static extern int switch_core_set_var_conditional(string jarg1, string jarg2, string jarg3);
 
@@ -8812,6 +9138,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_findall_matching_var")]
   public static extern IntPtr switch_core_session_findall_matching_var(string jarg1, string jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_findall")]
+  public static extern IntPtr switch_core_session_findall();
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_hupall_endpoint")]
   public static extern void switch_core_session_hupall_endpoint(HandleRef jarg1, int jarg2);
 
@@ -9610,6 +9939,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_default_ptime")]
   public static extern uint switch_default_ptime(string jarg1, uint jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_default_rate")]
+  public static extern uint switch_default_rate(string jarg1, uint jarg2);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_core_add_registration")]
   public static extern int switch_core_add_registration(string jarg1, string jarg2, string jarg3, string jarg4, uint jarg5, string jarg6, string jarg7, string jarg8, string jarg9);
 
@@ -9703,6 +10035,18 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_fork")]
   public static extern IntPtr switch_fork();
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_gen_certs")]
+  public static extern int switch_core_gen_certs(string jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_cert_gen_fingerprint")]
+  public static extern int switch_core_cert_gen_fingerprint(string jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_cert_expand_fingerprint")]
+  public static extern int switch_core_cert_expand_fingerprint(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_core_cert_verify")]
+  public static extern int switch_core_cert_verify(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_interface_module_name_set")]
   public static extern void switch_loadable_module_interface_module_name_set(HandleRef jarg1, string jarg2);
 
@@ -10039,6 +10383,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_testv6_subnet")]
   public static extern int switch_testv6_subnet(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_print_host")]
+  public static extern string switch_print_host(HandleRef jarg1, string jarg2, HandleRef jarg3);
+
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_SMAX_get")]
   public static extern int SWITCH_SMAX_get();
 
@@ -10231,6 +10578,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_string_match")]
   public static extern int switch_string_match(string jarg1, uint jarg2, string jarg3, uint jarg4);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_strcasecmp_any")]
+  public static extern int switch_strcasecmp_any(string jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_util_quote_shell_arg")]
   public static extern string switch_util_quote_shell_arg(string jarg1);
 
@@ -10357,6 +10707,18 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_caller_id_number_get")]
   public static extern string switch_caller_profile_caller_id_number_get(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_name_set")]
+  public static extern void switch_caller_profile_orig_caller_id_name_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_name_get")]
+  public static extern string switch_caller_profile_orig_caller_id_name_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_number_set")]
+  public static extern void switch_caller_profile_orig_caller_id_number_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_number_get")]
+  public static extern string switch_caller_profile_orig_caller_id_number_get(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_callee_id_name_set")]
   public static extern void switch_caller_profile_callee_id_name_set(HandleRef jarg1, string jarg2);
 
@@ -11614,6 +11976,18 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_prefix_get")]
   public static extern string switch_file_handle_prefix_get(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_max_samples_set")]
+  public static extern void switch_file_handle_max_samples_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_max_samples_get")]
+  public static extern int switch_file_handle_max_samples_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_params_set")]
+  public static extern void switch_file_handle_params_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_params_get")]
+  public static extern IntPtr switch_file_handle_params_get(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_new_switch_file_handle")]
   public static extern IntPtr new_switch_file_handle();
 
@@ -13069,6 +13443,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_caller_profile")]
   public static extern void switch_channel_set_caller_profile(HandleRef jarg1, HandleRef jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_step_caller_profile")]
+  public static extern void switch_channel_step_caller_profile(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_caller_profile")]
   public static extern IntPtr switch_channel_get_caller_profile(HandleRef jarg1);
 
@@ -13126,6 +13503,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_del_variable_prefix")]
   public static extern uint switch_channel_del_variable_prefix(HandleRef jarg1, string jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_transfer_variable_prefix")]
+  public static extern int switch_channel_transfer_variable_prefix(HandleRef jarg1, HandleRef jarg2, string jarg3);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_export_variable_var_check")]
   public static extern int switch_channel_export_variable_var_check(HandleRef jarg1, string jarg2, string jarg3, string jarg4, int jarg5);
 
@@ -13165,11 +13545,14 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_caller_extension")]
   public static extern void switch_channel_set_caller_extension(HandleRef jarg1, HandleRef jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_invert_cid")]
+  public static extern void switch_channel_invert_cid(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_flip_cid")]
   public static extern void switch_channel_flip_cid(HandleRef jarg1);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_sort_cid")]
-  public static extern void switch_channel_sort_cid(HandleRef jarg1, int jarg2);
+  public static extern void switch_channel_sort_cid(HandleRef jarg1);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_caller_extension")]
   public static extern IntPtr switch_channel_get_caller_extension(HandleRef jarg1);
@@ -13396,6 +13779,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_state_thread_unlock")]
   public static extern void switch_channel_state_thread_unlock(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_state_thread_trylock")]
+  public static extern int switch_channel_state_thread_trylock(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_buffer_create")]
   public static extern int switch_buffer_create(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
 
@@ -14053,6 +14439,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_record_session")]
   public static extern int switch_ivr_record_session(HandleRef jarg1, string jarg2, uint jarg3, HandleRef jarg4);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_transfer_recordings")]
+  public static extern int switch_ivr_transfer_recordings(HandleRef jarg1, HandleRef jarg2);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_eavesdrop_pop_eavesdropper")]
   public static extern int switch_ivr_eavesdrop_pop_eavesdropper(HandleRef jarg1, HandleRef jarg2);
 
@@ -14161,6 +14550,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_hold_uuid")]
   public static extern int switch_ivr_hold_uuid(string jarg1, string jarg2, int jarg3);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_hold_toggle_uuid")]
+  public static extern int switch_ivr_hold_toggle_uuid(string jarg1, string jarg2, int jarg3);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_unhold_uuid")]
   public static extern int switch_ivr_unhold_uuid(string jarg1);
 
@@ -14380,6 +14772,9 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_blind_transfer_ack")]
   public static extern int switch_ivr_blind_transfer_ack(HandleRef jarg1, int jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_record_session_mask")]
+  public static extern int switch_ivr_record_session_mask(HandleRef jarg1, string jarg2, int jarg3);
+
   [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_RTP_MAX_BUF_LEN_get")]
   public static extern int SWITCH_RTP_MAX_BUF_LEN_get();
 
@@ -14437,6 +14832,123 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_rtp_crypto_key")]
   public static extern void delete_switch_rtp_crypto_key(HandleRef jarg1);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_foundation_set")]
+  public static extern void icand_t_foundation_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_foundation_get")]
+  public static extern string icand_t_foundation_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_component_id_set")]
+  public static extern void icand_t_component_id_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_component_id_get")]
+  public static extern int icand_t_component_id_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_transport_set")]
+  public static extern void icand_t_transport_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_transport_get")]
+  public static extern string icand_t_transport_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_priority_set")]
+  public static extern void icand_t_priority_set(HandleRef jarg1, uint jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_priority_get")]
+  public static extern uint icand_t_priority_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_addr_set")]
+  public static extern void icand_t_con_addr_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_addr_get")]
+  public static extern string icand_t_con_addr_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_port_set")]
+  public static extern void icand_t_con_port_set(HandleRef jarg1, ushort jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_port_get")]
+  public static extern ushort icand_t_con_port_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_cand_type_set")]
+  public static extern void icand_t_cand_type_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_cand_type_get")]
+  public static extern string icand_t_cand_type_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_raddr_set")]
+  public static extern void icand_t_raddr_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_raddr_get")]
+  public static extern string icand_t_raddr_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_rport_set")]
+  public static extern void icand_t_rport_set(HandleRef jarg1, ushort jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_rport_get")]
+  public static extern ushort icand_t_rport_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_generation_set")]
+  public static extern void icand_t_generation_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_generation_get")]
+  public static extern string icand_t_generation_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_ready_set")]
+  public static extern void icand_t_ready_set(HandleRef jarg1, byte jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_icand_t_ready_get")]
+  public static extern byte icand_t_ready_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_icand_t")]
+  public static extern IntPtr new_icand_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_icand_t")]
+  public static extern void delete_icand_t(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_MAX_CAND_get")]
+  public static extern int MAX_CAND_get();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cands_set")]
+  public static extern void ice_t_cands_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cands_get")]
+  public static extern IntPtr ice_t_cands_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cand_idx_set")]
+  public static extern void ice_t_cand_idx_set(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cand_idx_get")]
+  public static extern int ice_t_cand_idx_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_chosen_set")]
+  public static extern void ice_t_chosen_set(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_chosen_get")]
+  public static extern IntPtr ice_t_chosen_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_ufrag_set")]
+  public static extern void ice_t_ufrag_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_ufrag_get")]
+  public static extern string ice_t_ufrag_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_pwd_set")]
+  public static extern void ice_t_pwd_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_pwd_get")]
+  public static extern string ice_t_pwd_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_options_set")]
+  public static extern void ice_t_options_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_ice_t_options_get")]
+  public static extern string ice_t_options_get(HandleRef jarg1);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_new_ice_t")]
+  public static extern IntPtr new_ice_t();
+
+  [DllImport("mod_managed", EntryPoint="CSharp_delete_ice_t")]
+  public static extern void delete_ice_t(HandleRef jarg1);
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_add_crypto_key")]
   public static extern int switch_rtp_add_crypto_key(HandleRef jarg1, int jarg2, uint jarg3, int jarg4, HandleRef jarg5, HandleRef jarg6);
 
@@ -14471,10 +14983,10 @@ class freeswitchPINVOKE {
   public static extern int switch_rtp_change_interval(HandleRef jarg1, uint jarg2, uint jarg3);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_create")]
-  public static extern int switch_rtp_create(HandleRef jarg1, byte jarg2, uint jarg3, uint jarg4, uint jarg5, string jarg6, ref string jarg7, HandleRef jarg8);
+  public static extern int switch_rtp_create(HandleRef jarg1, byte jarg2, uint jarg3, uint jarg4, HandleRef jarg5, string jarg6, ref string jarg7, HandleRef jarg8);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_new")]
-  public static extern IntPtr switch_rtp_new(string jarg1, ushort jarg2, string jarg3, ushort jarg4, byte jarg5, uint jarg6, uint jarg7, uint jarg8, string jarg9, ref string jarg10, HandleRef jarg11);
+  public static extern IntPtr switch_rtp_new(string jarg1, ushort jarg2, string jarg3, ushort jarg4, byte jarg5, uint jarg6, uint jarg7, HandleRef jarg8, string jarg9, ref string jarg10, HandleRef jarg11);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_remote_address")]
   public static extern int switch_rtp_set_remote_address(HandleRef jarg1, string jarg2, ushort jarg3, ushort jarg4, int jarg5, ref string jarg6);
@@ -14513,13 +15025,10 @@ class freeswitchPINVOKE {
   public static extern void switch_rtp_destroy(HandleRef jarg1);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_ice")]
-  public static extern int switch_rtp_activate_ice(HandleRef jarg1, string jarg2, string jarg3, string jarg4);
-
-  [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_rtcp_ice")]
-  public static extern int switch_rtp_activate_rtcp_ice(HandleRef jarg1, string jarg2, string jarg3, string jarg4);
+  public static extern int switch_rtp_activate_ice(HandleRef jarg1, string jarg2, string jarg3, string jarg4, string jarg5, int jarg6, HandleRef jarg7, HandleRef jarg8);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_rtcp")]
-  public static extern int switch_rtp_activate_rtcp(HandleRef jarg1, int jarg2, ushort jarg3);
+  public static extern int switch_rtp_activate_rtcp(HandleRef jarg1, int jarg2, ushort jarg3, int jarg4);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_jitter_buffer")]
   public static extern int switch_rtp_activate_jitter_buffer(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6);
@@ -14537,13 +15046,19 @@ class freeswitchPINVOKE {
   public static extern IntPtr switch_rtp_get_jitter_buffer(HandleRef jarg1);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_flag")]
-  public static extern void switch_rtp_set_flag(HandleRef jarg1, uint jarg2);
+  public static extern void switch_rtp_set_flag(HandleRef jarg1, int jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_flags")]
+  public static extern void switch_rtp_set_flags(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_clear_flags")]
+  public static extern void switch_rtp_clear_flags(HandleRef jarg1, HandleRef jarg2);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_test_flag")]
-  public static extern uint switch_rtp_test_flag(HandleRef jarg1, uint jarg2);
+  public static extern uint switch_rtp_test_flag(HandleRef jarg1, int jarg2);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_clear_flag")]
-  public static extern void switch_rtp_clear_flag(HandleRef jarg1, uint jarg2);
+  public static extern void switch_rtp_clear_flag(HandleRef jarg1, int jarg2);
 
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_rtp_socket")]
   public static extern IntPtr switch_rtp_get_rtp_socket(HandleRef jarg1);
@@ -14638,6 +15153,12 @@ class freeswitchPINVOKE {
   [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_interdigit_delay")]
   public static extern void switch_rtp_set_interdigit_delay(HandleRef jarg1, uint jarg2);
 
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_add_dtls")]
+  public static extern int switch_rtp_add_dtls(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, int jarg4);
+
+  [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_has_dtls")]
+  public static extern int switch_rtp_has_dtls();
+
   [DllImport("mod_managed", EntryPoint="CSharp_switch_log_node_t_data_set")]
   public static extern void switch_log_node_t_data_set(HandleRef jarg1, string jarg2);
 
@@ -15940,6 +16461,288 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class icand_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal icand_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(icand_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~icand_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_icand_t(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public string foundation {
+    set {
+      freeswitchPINVOKE.icand_t_foundation_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.icand_t_foundation_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public int component_id {
+    set {
+      freeswitchPINVOKE.icand_t_component_id_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.icand_t_component_id_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string transport {
+    set {
+      freeswitchPINVOKE.icand_t_transport_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.icand_t_transport_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public uint priority {
+    set {
+      freeswitchPINVOKE.icand_t_priority_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.icand_t_priority_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string con_addr {
+    set {
+      freeswitchPINVOKE.icand_t_con_addr_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.icand_t_con_addr_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public ushort con_port {
+    set {
+      freeswitchPINVOKE.icand_t_con_port_set(swigCPtr, value);
+    } 
+    get {
+      ushort ret = freeswitchPINVOKE.icand_t_con_port_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string cand_type {
+    set {
+      freeswitchPINVOKE.icand_t_cand_type_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.icand_t_cand_type_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string raddr {
+    set {
+      freeswitchPINVOKE.icand_t_raddr_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.icand_t_raddr_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public ushort rport {
+    set {
+      freeswitchPINVOKE.icand_t_rport_set(swigCPtr, value);
+    } 
+    get {
+      ushort ret = freeswitchPINVOKE.icand_t_rport_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string generation {
+    set {
+      freeswitchPINVOKE.icand_t_generation_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.icand_t_generation_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public byte ready {
+    set {
+      freeswitchPINVOKE.icand_t_ready_set(swigCPtr, value);
+    } 
+    get {
+      byte ret = freeswitchPINVOKE.icand_t_ready_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public icand_t() : this(freeswitchPINVOKE.new_icand_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 ice_proto_t {
+  IPR_RTP,
+  IPR_RTCP
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * 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 ice_t : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal ice_t(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(ice_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~ice_t() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_ice_t(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public SWIGTYPE_p_a_2__icand_s cands {
+    set {
+      freeswitchPINVOKE.ice_t_cands_set(swigCPtr, SWIGTYPE_p_a_2__icand_s.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.ice_t_cands_get(swigCPtr);
+      SWIGTYPE_p_a_2__icand_s ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_a_2__icand_s(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public int cand_idx {
+    set {
+      freeswitchPINVOKE.ice_t_cand_idx_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.ice_t_cand_idx_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_int chosen {
+    set {
+      freeswitchPINVOKE.ice_t_chosen_set(swigCPtr, SWIGTYPE_p_int.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.ice_t_chosen_get(swigCPtr);
+      SWIGTYPE_p_int ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_int(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public string ufrag {
+    set {
+      freeswitchPINVOKE.ice_t_ufrag_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.ice_t_ufrag_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string pwd {
+    set {
+      freeswitchPINVOKE.ice_t_pwd_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.ice_t_pwd_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string options {
+    set {
+      freeswitchPINVOKE.ice_t_options_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.ice_t_options_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public ice_t() : this(freeswitchPINVOKE.new_ice_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 input_callback_state_t : IDisposable {
   private HandleRef swigCPtr;
   protected bool swigCMemOwn;
@@ -16360,6 +17163,36 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class SWIGTYPE_p_a_2__icand_s {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_a_2__icand_s(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_a_2__icand_s() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_a_2__icand_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_apr_pool_t {
   private HandleRef swigCPtr;
 
@@ -17770,6 +18603,36 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class SWIGTYPE_p_f_p_switch_core_session_p_void__p_void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_void__p_void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_void__p_void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_void__p_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__switch_status_t {
   private HandleRef swigCPtr;
 
@@ -20620,6 +21483,36 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class SWIGTYPE_p_switch_core_media_ice_type_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_switch_core_media_ice_type_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_switch_core_media_ice_type_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_switch_core_media_ice_type_t 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_switch_core_port_allocator {
   private HandleRef swigCPtr;
 
@@ -21280,6 +22173,36 @@ namespace FreeSWITCH.Native {
 using System;
 using System.Runtime.InteropServices;
 
+public class SWIGTYPE_p_switch_rtp_flag_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_switch_rtp_flag_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_switch_rtp_flag_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_switch_rtp_flag_t 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_switch_say_file_handle {
   private HandleRef swigCPtr;
 
@@ -21794,6 +22717,8 @@ public enum switch_abc_type_t {
   SWITCH_ABC_TYPE_WRITE_REPLACE,
   SWITCH_ABC_TYPE_READ_REPLACE,
   SWITCH_ABC_TYPE_READ_PING,
+  SWITCH_ABC_TYPE_TAP_NATIVE_READ,
+  SWITCH_ABC_TYPE_TAP_NATIVE_WRITE,
   SWITCH_ABC_TYPE_CLOSE
 }
 
@@ -23876,6 +24801,26 @@ public class switch_caller_profile : IDisposable {
     } 
   }
 
+  public string orig_caller_id_name {
+    set {
+      freeswitchPINVOKE.switch_caller_profile_orig_caller_id_name_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_caller_profile_orig_caller_id_name_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public string orig_caller_id_number {
+    set {
+      freeswitchPINVOKE.switch_caller_profile_orig_caller_id_number_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_caller_profile_orig_caller_id_number_get(swigCPtr);
+      return ret;
+    } 
+  }
+
   public string callee_id_name {
     set {
       freeswitchPINVOKE.switch_caller_profile_callee_id_name_set(swigCPtr, value);
@@ -24391,6 +25336,7 @@ public enum switch_channel_flag_t {
   CF_JITTERBUFFER,
   CF_JITTERBUFFER_PLC,
   CF_DIALPLAN,
+  CF_BLEG,
   CF_BLOCK_BROADCAST_UNTIL_MEDIA,
   CF_CNG_PLC,
   CF_ATTENDED_TRANSFER,
@@ -24419,6 +25365,27 @@ public enum switch_channel_flag_t {
   CF_EARLY_OK,
   CF_MEDIA_TRANS,
   CF_HOLD_ON_BRIDGE,
+  CF_SECURE,
+  CF_CRYPTO_RECOVER,
+  CF_LIBERAL_DTMF,
+  CF_SLA_BARGE,
+  CF_SLA_BARGING,
+  CF_PROTO_HOLD,
+  CF_HOLD_LOCK,
+  CF_VIDEO_POSSIBLE,
+  CF_NOTIMER_DURING_BRIDGE,
+  CF_PASS_RFC2833,
+  CF_T38_PASSTHRU,
+  CF_DROP_DTMF,
+  CF_REINVITE,
+  CF_AUTOFLUSH_DURING_BRIDGE,
+  CF_RTP_NOTIMER_DURING_BRIDGE,
+  CF_WEBRTC,
+  CF_WEBRTC_MOZ,
+  CF_ICE,
+  CF_DTLS,
+  CF_VERBOSE_SDP,
+  CF_DTLS_OK,
   CF_FLAG_MAX
 }
 
@@ -26882,6 +27849,16 @@ public class switch_directories : IDisposable {
     } 
   }
 
+  public string certs_dir {
+    set {
+      freeswitchPINVOKE.switch_directories_certs_dir_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.switch_directories_certs_dir_get(swigCPtr);
+      return ret;
+    } 
+  }
+
   public switch_directories() : this(freeswitchPINVOKE.new_switch_directories(), true) {
   }
 
@@ -28335,6 +29312,27 @@ public class switch_file_handle : IDisposable {
     } 
   }
 
+  public int max_samples {
+    set {
+      freeswitchPINVOKE.switch_file_handle_max_samples_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.switch_file_handle_max_samples_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public switch_event params {
+    set {
+      freeswitchPINVOKE.switch_file_handle_params_set(swigCPtr, switch_event.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.switch_file_handle_params_get(swigCPtr);
+      switch_event ret = (cPtr == IntPtr.Zero) ? null : new switch_event(cPtr, false);
+      return ret;
+    } 
+  }
+
   public switch_file_handle() : this(freeswitchPINVOKE.new_switch_file_handle(), true) {
   }
 
@@ -28816,7 +29814,8 @@ namespace FreeSWITCH.Native {
   SFF_DYNAMIC = (1 << 6),
   SFF_ZRTP = (1 << 7),
   SFF_UDPTL_PACKET = (1 << 8),
-  SFF_NOT_AUDIO = (1 << 9)
+  SFF_NOT_AUDIO = (1 << 9),
+  SFF_RTCP = (1 << 10)
 }
 
 }
@@ -31332,11 +32331,16 @@ namespace FreeSWITCH.Native {
   SMBF_READ_PING = (1 << 4),
   SMBF_STEREO = (1 << 5),
   SMBF_ANSWER_REQ = (1 << 6),
-  SMBF_THREAD_LOCK = (1 << 7),
-  SMBF_PRUNE = (1 << 8),
-  SMBF_NO_PAUSE = (1 << 9),
-  SMBF_STEREO_SWAP = (1 << 10),
-  SMBF_LOCK = (1 << 11)
+  SMBF_BRIDGE_REQ = (1 << 7),
+  SMBF_THREAD_LOCK = (1 << 8),
+  SMBF_PRUNE = (1 << 9),
+  SMBF_NO_PAUSE = (1 << 10),
+  SMBF_STEREO_SWAP = (1 << 11),
+  SMBF_LOCK = (1 << 12),
+  SMBF_TAP_NATIVE_READ = (1 << 13),
+  SMBF_TAP_NATIVE_WRITE = (1 << 14),
+  SMBF_ONE_ONLY = (1 << 15),
+  SMBF_MASK = (1 << 16)
 }
 
 }
@@ -31709,6 +32713,8 @@ namespace FreeSWITCH.Native {
 public enum switch_rtp_crypto_direction_t {
   SWITCH_RTP_CRYPTO_SEND,
   SWITCH_RTP_CRYPTO_RECV,
+  SWITCH_RTP_CRYPTO_SEND_RTCP,
+  SWITCH_RTP_CRYPTO_RECV_RTCP,
   SWITCH_RTP_CRYPTO_MAX
 }
 
@@ -31828,6 +32834,7 @@ public enum switch_rtp_crypto_key_type_t {
   NO_CRYPTO,
   AES_CM_128_HMAC_SHA1_80,
   AES_CM_128_HMAC_SHA1_32,
+  AES_CM_256_HMAC_SHA1_80,
   AES_CM_128_NULL_AUTH
 }
 
@@ -31842,38 +32849,40 @@ public enum switch_rtp_crypto_key_type_t {
 
 namespace FreeSWITCH.Native {
 
-[System.Flags] public enum switch_rtp_flag_enum_t {
-  SWITCH_RTP_FLAG_NOBLOCK = (1 << 0),
-  SWITCH_RTP_FLAG_IO = (1 << 1),
-  SWITCH_RTP_FLAG_USE_TIMER = (1 << 2),
-  SWITCH_RTP_FLAG_RTCP_PASSTHRU = (1 << 3),
-  SWITCH_RTP_FLAG_SECURE_SEND = (1 << 4),
-  SWITCH_RTP_FLAG_SECURE_RECV = (1 << 5),
-  SWITCH_RTP_FLAG_AUTOADJ = (1 << 6),
-  SWITCH_RTP_FLAG_RAW_WRITE = (1 << 7),
-  SWITCH_RTP_FLAG_GOOGLEHACK = (1 << 8),
-  SWITCH_RTP_FLAG_VAD = (1 << 9),
-  SWITCH_RTP_FLAG_BREAK = (1 << 10),
-  SWITCH_RTP_FLAG_UDPTL = (1 << 11),
-  SWITCH_RTP_FLAG_DATAWAIT = (1 << 12),
-  SWITCH_RTP_FLAG_BYTESWAP = (1 << 13),
-  SWITCH_RTP_FLAG_PASS_RFC2833 = (1 << 14),
-  SWITCH_RTP_FLAG_AUTO_CNG = (1 << 15),
-  SWITCH_RTP_FLAG_SECURE_SEND_RESET = (1 << 16),
-  SWITCH_RTP_FLAG_SECURE_RECV_RESET = (1 << 17),
-  SWITCH_RTP_FLAG_PROXY_MEDIA = (1 << 18),
-  SWITCH_RTP_FLAG_SHUTDOWN = (1 << 19),
-  SWITCH_RTP_FLAG_FLUSH = (1 << 20),
-  SWITCH_RTP_FLAG_AUTOFLUSH = (1 << 21),
-  SWITCH_RTP_FLAG_STICKY_FLUSH = (1 << 22),
-  SWITCH_ZRTP_FLAG_SECURE_SEND = (1 << 23),
-  SWITCH_ZRTP_FLAG_SECURE_RECV = (1 << 24),
-  SWITCH_ZRTP_FLAG_SECURE_MITM_SEND = (1 << 25),
-  SWITCH_ZRTP_FLAG_SECURE_MITM_RECV = (1 << 26),
-  SWITCH_RTP_FLAG_DEBUG_RTP_READ = (1 << 27),
-  SWITCH_RTP_FLAG_DEBUG_RTP_WRITE = (1 << 28),
-  SWITCH_RTP_FLAG_VIDEO = (1 << 29),
-  SWITCH_RTP_FLAG_ENABLE_RTCP = (1 << 30)
+public enum switch_rtp_flag_t {
+  SWITCH_RTP_FLAG_NOBLOCK = 0,
+  SWITCH_RTP_FLAG_IO,
+  SWITCH_RTP_FLAG_USE_TIMER,
+  SWITCH_RTP_FLAG_RTCP_PASSTHRU,
+  SWITCH_RTP_FLAG_SECURE_SEND,
+  SWITCH_RTP_FLAG_SECURE_RECV,
+  SWITCH_RTP_FLAG_AUTOADJ,
+  SWITCH_RTP_FLAG_RAW_WRITE,
+  SWITCH_RTP_FLAG_GOOGLEHACK,
+  SWITCH_RTP_FLAG_VAD,
+  SWITCH_RTP_FLAG_BREAK,
+  SWITCH_RTP_FLAG_UDPTL,
+  SWITCH_RTP_FLAG_DATAWAIT,
+  SWITCH_RTP_FLAG_BYTESWAP,
+  SWITCH_RTP_FLAG_PASS_RFC2833,
+  SWITCH_RTP_FLAG_AUTO_CNG,
+  SWITCH_RTP_FLAG_SECURE_SEND_RESET,
+  SWITCH_RTP_FLAG_SECURE_RECV_RESET,
+  SWITCH_RTP_FLAG_PROXY_MEDIA,
+  SWITCH_RTP_FLAG_SHUTDOWN,
+  SWITCH_RTP_FLAG_FLUSH,
+  SWITCH_RTP_FLAG_AUTOFLUSH,
+  SWITCH_RTP_FLAG_STICKY_FLUSH,
+  SWITCH_ZRTP_FLAG_SECURE_SEND,
+  SWITCH_ZRTP_FLAG_SECURE_RECV,
+  SWITCH_ZRTP_FLAG_SECURE_MITM_SEND,
+  SWITCH_ZRTP_FLAG_SECURE_MITM_RECV,
+  SWITCH_RTP_FLAG_DEBUG_RTP_READ,
+  SWITCH_RTP_FLAG_DEBUG_RTP_WRITE,
+  SWITCH_RTP_FLAG_VIDEO,
+  SWITCH_RTP_FLAG_ENABLE_RTCP,
+  SWITCH_RTP_FLAG_RTCP_MUX,
+  SWITCH_RTP_FLAG_INVALID
 }
 
 }