/* ----------------------------------------------------------------------------
 * 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 freeswitch {
  public static switch_directories SWITCH_GLOBAL_dirs {
    set {
      freeswitchPINVOKE.SWITCH_GLOBAL_dirs_set(switch_directories.getCPtr(value));
    } 
    get {
      IntPtr cPtr = freeswitchPINVOKE.SWITCH_GLOBAL_dirs_get();
      switch_directories ret = (cPtr == IntPtr.Zero) ? null : new switch_directories(cPtr, false);
      return ret;
    } 
  }

  public static int switch_core_db_close(SWIGTYPE_p_sqlite3 db) {
    int ret = freeswitchPINVOKE.switch_core_db_close(SWIGTYPE_p_sqlite3.getCPtr(db));
    return ret;
  }

  public static int switch_core_db_open(string filename, SWIGTYPE_p_p_sqlite3 ppDb) {
    int ret = freeswitchPINVOKE.switch_core_db_open(filename, SWIGTYPE_p_p_sqlite3.getCPtr(ppDb));
    return ret;
  }

  public static SWIGTYPE_p_unsigned_char switch_core_db_column_text(SWIGTYPE_p_sqlite3_stmt stmt, int iCol) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_db_column_text(SWIGTYPE_p_sqlite3_stmt.getCPtr(stmt), iCol);
    SWIGTYPE_p_unsigned_char ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
    return ret;
  }

  public static string switch_core_db_column_name(SWIGTYPE_p_sqlite3_stmt stmt, int N) {
    string ret = freeswitchPINVOKE.switch_core_db_column_name(SWIGTYPE_p_sqlite3_stmt.getCPtr(stmt), N);
    return ret;
  }

  public static int switch_core_db_column_count(SWIGTYPE_p_sqlite3_stmt pStmt) {
    int ret = freeswitchPINVOKE.switch_core_db_column_count(SWIGTYPE_p_sqlite3_stmt.getCPtr(pStmt));
    return ret;
  }

  public static string switch_core_db_errmsg(SWIGTYPE_p_sqlite3 db) {
    string ret = freeswitchPINVOKE.switch_core_db_errmsg(SWIGTYPE_p_sqlite3.getCPtr(db));
    return ret;
  }

  public static int switch_core_db_exec(SWIGTYPE_p_sqlite3 db, string sql, SWIGTYPE_p_f_p_void_int_p_p_char_p_p_char__int callback, SWIGTYPE_p_void data, SWIGTYPE_p_p_char errmsg) {
    int ret = freeswitchPINVOKE.switch_core_db_exec(SWIGTYPE_p_sqlite3.getCPtr(db), sql, SWIGTYPE_p_f_p_void_int_p_p_char_p_p_char__int.getCPtr(callback), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_p_char.getCPtr(errmsg));
    return ret;
  }

  public static int switch_core_db_finalize(SWIGTYPE_p_sqlite3_stmt pStmt) {
    int ret = freeswitchPINVOKE.switch_core_db_finalize(SWIGTYPE_p_sqlite3_stmt.getCPtr(pStmt));
    return ret;
  }

  public static int switch_core_db_prepare(SWIGTYPE_p_sqlite3 db, string zSql, int nBytes, SWIGTYPE_p_p_sqlite3_stmt ppStmt, SWIGTYPE_p_p_char pzTail) {
    int ret = freeswitchPINVOKE.switch_core_db_prepare(SWIGTYPE_p_sqlite3.getCPtr(db), zSql, nBytes, SWIGTYPE_p_p_sqlite3_stmt.getCPtr(ppStmt), SWIGTYPE_p_p_char.getCPtr(pzTail));
    return ret;
  }

  public static int switch_core_db_step(SWIGTYPE_p_sqlite3_stmt stmt) {
    int ret = freeswitchPINVOKE.switch_core_db_step(SWIGTYPE_p_sqlite3_stmt.getCPtr(stmt));
    return ret;
  }

  public static int switch_core_db_reset(SWIGTYPE_p_sqlite3_stmt pStmt) {
    int ret = freeswitchPINVOKE.switch_core_db_reset(SWIGTYPE_p_sqlite3_stmt.getCPtr(pStmt));
    return ret;
  }

  public static int switch_core_db_bind_int(SWIGTYPE_p_sqlite3_stmt pStmt, int i, int iValue) {
    int ret = freeswitchPINVOKE.switch_core_db_bind_int(SWIGTYPE_p_sqlite3_stmt.getCPtr(pStmt), i, iValue);
    return ret;
  }

  public static int switch_core_db_bind_int64(SWIGTYPE_p_sqlite3_stmt pStmt, int i, long iValue) {
    int ret = freeswitchPINVOKE.switch_core_db_bind_int64(SWIGTYPE_p_sqlite3_stmt.getCPtr(pStmt), i, iValue);
    return ret;
  }

  public static int switch_core_db_bind_text(SWIGTYPE_p_sqlite3_stmt pStmt, int i, string zData, int nData, SWIGTYPE_p_f_p_void__void xDel) {
    int ret = freeswitchPINVOKE.switch_core_db_bind_text(SWIGTYPE_p_sqlite3_stmt.getCPtr(pStmt), i, zData, nData, SWIGTYPE_p_f_p_void__void.getCPtr(xDel));
    return ret;
  }

  public static int switch_core_db_bind_double(SWIGTYPE_p_sqlite3_stmt pStmt, int i, double dValue) {
    int ret = freeswitchPINVOKE.switch_core_db_bind_double(SWIGTYPE_p_sqlite3_stmt.getCPtr(pStmt), i, dValue);
    return ret;
  }

  public static long switch_core_db_last_insert_rowid(SWIGTYPE_p_sqlite3 db) {
    long ret = freeswitchPINVOKE.switch_core_db_last_insert_rowid(SWIGTYPE_p_sqlite3.getCPtr(db));
    return ret;
  }

  public static int switch_core_db_get_table(SWIGTYPE_p_sqlite3 db, string sql, SWIGTYPE_p_p_p_char resultp, SWIGTYPE_p_int nrow, SWIGTYPE_p_int ncolumn, SWIGTYPE_p_p_char errmsg) {
    int ret = freeswitchPINVOKE.switch_core_db_get_table(SWIGTYPE_p_sqlite3.getCPtr(db), sql, SWIGTYPE_p_p_p_char.getCPtr(resultp), SWIGTYPE_p_int.getCPtr(nrow), SWIGTYPE_p_int.getCPtr(ncolumn), SWIGTYPE_p_p_char.getCPtr(errmsg));
    return ret;
  }

  public static void switch_core_db_free_table(SWIGTYPE_p_p_char result) {
    freeswitchPINVOKE.switch_core_db_free_table(SWIGTYPE_p_p_char.getCPtr(result));
  }

  public static void switch_core_db_free(string z) {
    freeswitchPINVOKE.switch_core_db_free(z);
  }

  public static int switch_core_db_changes(SWIGTYPE_p_sqlite3 db) {
    int ret = freeswitchPINVOKE.switch_core_db_changes(SWIGTYPE_p_sqlite3.getCPtr(db));
    return ret;
  }

  public static string switch_mprintf(string zFormat) {
    string ret = freeswitchPINVOKE.switch_mprintf(zFormat);
    return ret;
  }

  public static SWIGTYPE_p_real_pcre switch_regex_compile(string pattern, int options, SWIGTYPE_p_p_char errorptr, SWIGTYPE_p_int erroroffset, SWIGTYPE_p_unsigned_char tables) {
    IntPtr cPtr = freeswitchPINVOKE.switch_regex_compile(pattern, options, SWIGTYPE_p_p_char.getCPtr(errorptr), SWIGTYPE_p_int.getCPtr(erroroffset), SWIGTYPE_p_unsigned_char.getCPtr(tables));
    SWIGTYPE_p_real_pcre ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_real_pcre(cPtr, false);
    return ret;
  }

  public static int switch_regex_copy_substring(string subject, SWIGTYPE_p_int ovector, int stringcount, int stringnumber, string buffer, int size) {
    int ret = freeswitchPINVOKE.switch_regex_copy_substring(subject, SWIGTYPE_p_int.getCPtr(ovector), stringcount, stringnumber, buffer, size);
    return ret;
  }

  public static void switch_regex_free(SWIGTYPE_p_void data) {
    freeswitchPINVOKE.switch_regex_free(SWIGTYPE_p_void.getCPtr(data));
  }

  public static int switch_regex_perform(string field, string expression, SWIGTYPE_p_p_real_pcre new_re, SWIGTYPE_p_int ovector, uint olen) {
    int ret = freeswitchPINVOKE.switch_regex_perform(field, expression, SWIGTYPE_p_p_real_pcre.getCPtr(new_re), SWIGTYPE_p_int.getCPtr(ovector), olen);
    return ret;
  }

  public static void switch_perform_substitution(SWIGTYPE_p_real_pcre re, int match_count, string data, string field_data, string substituted, SWIGTYPE_p_switch_size_t len, SWIGTYPE_p_int ovector) {
    freeswitchPINVOKE.switch_perform_substitution(SWIGTYPE_p_real_pcre.getCPtr(re), match_count, data, field_data, substituted, SWIGTYPE_p_switch_size_t.getCPtr(len), SWIGTYPE_p_int.getCPtr(ovector));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
  }

  public static switch_status_t switch_regex_match(string target, string expression) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_regex_match(target, expression);
    return ret;
  }

  public static switch_status_t switch_core_media_bug_add(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t callback, SWIGTYPE_p_void user_data, SWIGTYPE_p_time_t stop_time, uint flags, SWIGTYPE_p_p_switch_media_bug new_bug) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_add(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t.getCPtr(callback), SWIGTYPE_p_void.getCPtr(user_data), SWIGTYPE_p_time_t.getCPtr(stop_time), flags, SWIGTYPE_p_p_switch_media_bug.getCPtr(new_bug));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_media_bug_get_user_data(SWIGTYPE_p_switch_media_bug bug) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_user_data(SWIGTYPE_p_switch_media_bug.getCPtr(bug));
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static switch_frame switch_core_media_bug_get_write_replace_frame(SWIGTYPE_p_switch_media_bug bug) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_write_replace_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));
  }

  public static switch_frame switch_core_media_bug_get_read_replace_frame(SWIGTYPE_p_switch_media_bug bug) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_read_replace_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug));
    switch_frame ret = (cPtr == IntPtr.Zero) ? null : new switch_frame(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_switch_core_session switch_core_media_bug_get_session(SWIGTYPE_p_switch_media_bug bug) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_session(SWIGTYPE_p_switch_media_bug.getCPtr(bug));
    SWIGTYPE_p_switch_core_session ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_core_session(cPtr, false);
    return ret;
  }

  public static uint switch_core_media_bug_test_flag(SWIGTYPE_p_switch_media_bug bug, uint flag) {
    uint ret = freeswitchPINVOKE.switch_core_media_bug_test_flag(SWIGTYPE_p_switch_media_bug.getCPtr(bug), flag);
    return ret;
  }

  public static void switch_core_media_bug_set_read_replace_frame(SWIGTYPE_p_switch_media_bug bug, switch_frame frame) {
    freeswitchPINVOKE.switch_core_media_bug_set_read_replace_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug), switch_frame.getCPtr(frame));
  }

  public static switch_status_t switch_core_media_bug_remove(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_media_bug bug) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_remove(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_media_bug.getCPtr(bug));
    return ret;
  }

  public static switch_status_t switch_core_media_bug_close(SWIGTYPE_p_p_switch_media_bug bug) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_close(SWIGTYPE_p_p_switch_media_bug.getCPtr(bug));
    return ret;
  }

  public static switch_status_t switch_core_media_bug_remove_all(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_remove_all(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_core_media_bug_read(SWIGTYPE_p_switch_media_bug bug, switch_frame frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_read(SWIGTYPE_p_switch_media_bug.getCPtr(bug), switch_frame.getCPtr(frame));
    return ret;
  }

  public static switch_status_t switch_core_port_allocator_new(ushort start, ushort end, uint flags, SWIGTYPE_p_p_switch_core_port_allocator new_allocator) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_port_allocator_new(start, end, flags, SWIGTYPE_p_p_switch_core_port_allocator.getCPtr(new_allocator));
    return ret;
  }

  public static switch_status_t switch_core_port_allocator_request_port(SWIGTYPE_p_switch_core_port_allocator alloc, SWIGTYPE_p_unsigned_short port_ptr) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_port_allocator_request_port(SWIGTYPE_p_switch_core_port_allocator.getCPtr(alloc), SWIGTYPE_p_unsigned_short.getCPtr(port_ptr));
    return ret;
  }

  public static switch_status_t switch_core_port_allocator_free_port(SWIGTYPE_p_switch_core_port_allocator alloc, ushort port) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_port_allocator_free_port(SWIGTYPE_p_switch_core_port_allocator.getCPtr(alloc), port);
    return ret;
  }

  public static void switch_core_port_allocator_destroy(SWIGTYPE_p_p_switch_core_port_allocator alloc) {
    freeswitchPINVOKE.switch_core_port_allocator_destroy(SWIGTYPE_p_p_switch_core_port_allocator.getCPtr(alloc));
  }

  public static switch_status_t switch_core_init(uint flags, switch_bool_t console, SWIGTYPE_p_p_char err) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_init(flags, (int)console, SWIGTYPE_p_p_char.getCPtr(err));
    return ret;
  }

  public static switch_status_t switch_core_init_and_modload(uint flags, switch_bool_t console, SWIGTYPE_p_p_char err) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_init_and_modload(flags, (int)console, SWIGTYPE_p_p_char.getCPtr(err));
    return ret;
  }

  public static uint switch_core_session_limit(uint new_limit) {
    uint ret = freeswitchPINVOKE.switch_core_session_limit(new_limit);
    return ret;
  }

  public static uint switch_core_sessions_per_second(uint new_limit) {
    uint ret = freeswitchPINVOKE.switch_core_sessions_per_second(new_limit);
    return ret;
  }

  public static switch_status_t switch_core_destroy() {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_destroy();
    return ret;
  }

  public static switch_status_t switch_core_session_signal_lock(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_signal_lock(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_core_session_signal_unlock(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_signal_unlock(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_core_session_read_lock(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_read_lock(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static void switch_core_session_write_lock(SWIGTYPE_p_switch_core_session session) {
    freeswitchPINVOKE.switch_core_session_write_lock(SWIGTYPE_p_switch_core_session.getCPtr(session));
  }

  public static void switch_core_session_rwunlock(SWIGTYPE_p_switch_core_session session) {
    freeswitchPINVOKE.switch_core_session_rwunlock(SWIGTYPE_p_switch_core_session.getCPtr(session));
  }

  public static int switch_core_add_state_handler(switch_state_handler_table state_handler) {
    int ret = freeswitchPINVOKE.switch_core_add_state_handler(switch_state_handler_table.getCPtr(state_handler));
    return ret;
  }

  public static switch_state_handler_table switch_core_get_state_handler(int index) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_get_state_handler(index);
    switch_state_handler_table ret = (cPtr == IntPtr.Zero) ? null : new switch_state_handler_table(cPtr, false);
    return ret;
  }

  public static void switch_core_memory_pool_tag(SWIGTYPE_p_apr_pool_t pool, string tag) {
    freeswitchPINVOKE.switch_core_memory_pool_tag(SWIGTYPE_p_apr_pool_t.getCPtr(pool), tag);
  }

  public static switch_status_t switch_core_perform_new_memory_pool(SWIGTYPE_p_p_apr_pool_t pool, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_perform_new_memory_pool(SWIGTYPE_p_p_apr_pool_t.getCPtr(pool), file, func, line);
    return ret;
  }

  public static switch_status_t switch_core_perform_destroy_memory_pool(SWIGTYPE_p_p_apr_pool_t pool, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_perform_destroy_memory_pool(SWIGTYPE_p_p_apr_pool_t.getCPtr(pool), file, func, line);
    return ret;
  }

  public static void switch_core_session_run(SWIGTYPE_p_switch_core_session session) {
    freeswitchPINVOKE.switch_core_session_run(SWIGTYPE_p_switch_core_session.getCPtr(session));
  }

  public static uint switch_core_session_running(SWIGTYPE_p_switch_core_session session) {
    uint ret = freeswitchPINVOKE.switch_core_session_running(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_perform_permanent_alloc(SWIGTYPE_p_switch_size_t memory, string file, string func, int line) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_perform_permanent_alloc(SWIGTYPE_p_switch_size_t.getCPtr(memory), file, func, line);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_perform_alloc(SWIGTYPE_p_apr_pool_t pool, SWIGTYPE_p_switch_size_t memory, string file, string func, int line) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_perform_alloc(SWIGTYPE_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_switch_size_t.getCPtr(memory), file, func, line);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_perform_session_alloc(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_switch_size_t memory, string file, string func, int line) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_perform_session_alloc(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_switch_size_t.getCPtr(memory), file, func, line);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static string switch_core_perform_permanent_strdup(string todup, string file, string func, int line) {
    string ret = freeswitchPINVOKE.switch_core_perform_permanent_strdup(todup, file, func, line);
    return ret;
  }

  public static string switch_core_perform_session_strdup(SWIGTYPE_p_switch_core_session session, string todup, string file, string func, int line) {
    string ret = freeswitchPINVOKE.switch_core_perform_session_strdup(SWIGTYPE_p_switch_core_session.getCPtr(session), todup, file, func, line);
    return ret;
  }

  public static string switch_core_perform_strdup(SWIGTYPE_p_apr_pool_t pool, string todup, string file, string func, int line) {
    string ret = freeswitchPINVOKE.switch_core_perform_strdup(SWIGTYPE_p_apr_pool_t.getCPtr(pool), todup, file, func, line);
    return ret;
  }

  public static string switch_core_session_sprintf(SWIGTYPE_p_switch_core_session session, string fmt) {
    string ret = freeswitchPINVOKE.switch_core_session_sprintf(SWIGTYPE_p_switch_core_session.getCPtr(session), fmt);
    return ret;
  }

  public static string switch_core_sprintf(SWIGTYPE_p_apr_pool_t pool, string fmt) {
    string ret = freeswitchPINVOKE.switch_core_sprintf(SWIGTYPE_p_apr_pool_t.getCPtr(pool), fmt);
    return ret;
  }

  public static SWIGTYPE_p_apr_pool_t switch_core_session_get_pool(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_pool(SWIGTYPE_p_switch_core_session.getCPtr(session));
    SWIGTYPE_p_apr_pool_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_apr_pool_t(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_switch_core_session switch_core_session_request(switch_endpoint_interface endpoint_interface, SWIGTYPE_p_p_apr_pool_t pool) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_request(switch_endpoint_interface.getCPtr(endpoint_interface), SWIGTYPE_p_p_apr_pool_t.getCPtr(pool));
    SWIGTYPE_p_switch_core_session ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_core_session(cPtr, false);
    return ret;
  }

  public static void switch_core_session_perform_destroy(SWIGTYPE_p_p_switch_core_session session, string file, string func, int line) {
    freeswitchPINVOKE.switch_core_session_perform_destroy(SWIGTYPE_p_p_switch_core_session.getCPtr(session), file, func, line);
  }

  public static uint switch_core_session_count() {
    uint ret = freeswitchPINVOKE.switch_core_session_count();
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_core_session_id() {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_core_session_id(), true);
    return ret;
  }

  public static SWIGTYPE_p_switch_core_session switch_core_session_request_by_name(string endpoint_name, SWIGTYPE_p_p_apr_pool_t pool) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_request_by_name(endpoint_name, SWIGTYPE_p_p_apr_pool_t.getCPtr(pool));
    SWIGTYPE_p_switch_core_session ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_core_session(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_core_session_thread_launch(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_thread_launch(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static SWIGTYPE_p_switch_channel switch_core_session_get_channel(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_channel(SWIGTYPE_p_switch_core_session.getCPtr(session));
    SWIGTYPE_p_switch_channel ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_channel(cPtr, false);
    return ret;
  }

  public static void switch_core_session_signal_state_change(SWIGTYPE_p_switch_core_session session) {
    freeswitchPINVOKE.switch_core_session_signal_state_change(SWIGTYPE_p_switch_core_session.getCPtr(session));
  }

  public static string switch_core_session_get_uuid(SWIGTYPE_p_switch_core_session session) {
    string ret = freeswitchPINVOKE.switch_core_session_get_uuid(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static string switch_core_get_uuid() {
    string ret = freeswitchPINVOKE.switch_core_get_uuid();
    return ret;
  }

  public static SWIGTYPE_p_switch_core_session switch_core_session_locate(string uuid_str) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_locate(uuid_str);
    SWIGTYPE_p_switch_core_session ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_core_session(cPtr, false);
    return ret;
  }

  public static string switch_core_get_variable(string varname) {
    string ret = freeswitchPINVOKE.switch_core_get_variable(varname);
    return ret;
  }

  public static void switch_core_set_variable(string varname, string value) {
    freeswitchPINVOKE.switch_core_set_variable(varname, value);
  }

  public static void switch_core_session_hupall(switch_call_cause_t cause) {
    freeswitchPINVOKE.switch_core_session_hupall((int)cause);
  }

  public static switch_status_t switch_core_session_message_send(string uuid_str, switch_core_session_message message) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_message_send(uuid_str, switch_core_session_message.getCPtr(message));
    return ret;
  }

  public static switch_status_t switch_core_session_queue_message(SWIGTYPE_p_switch_core_session session, switch_core_session_message message) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_queue_message(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_core_session_message.getCPtr(message));
    return ret;
  }

  public static switch_status_t switch_core_session_pass_indication(SWIGTYPE_p_switch_core_session session, switch_core_session_message_types_t indication) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_pass_indication(SWIGTYPE_p_switch_core_session.getCPtr(session), (int)indication);
    return ret;
  }

  public static switch_status_t switch_core_session_queue_indication(SWIGTYPE_p_switch_core_session session, switch_core_session_message_types_t indication) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_queue_indication(SWIGTYPE_p_switch_core_session.getCPtr(session), (int)indication);
    return ret;
  }

  public static switch_status_t switch_core_session_dequeue_message(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_core_session_message message) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_dequeue_message(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_core_session_message.getCPtr(message));
    return ret;
  }

  public static switch_status_t switch_core_session_flush_message(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_flush_message(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_core_session_event_send(string uuid_str, SWIGTYPE_p_p_switch_event arg1) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_event_send(uuid_str, SWIGTYPE_p_p_switch_event.getCPtr(arg1));
    return ret;
  }

  public static switch_app_log switch_core_session_get_app_log(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_app_log(SWIGTYPE_p_switch_core_session.getCPtr(session));
    switch_app_log ret = (cPtr == IntPtr.Zero) ? null : new switch_app_log(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_core_session_exec(SWIGTYPE_p_switch_core_session session, switch_application_interface application_interface, string arg) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_exec(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_application_interface.getCPtr(application_interface), arg);
    return ret;
  }

  public static switch_status_t switch_core_session_execute_application(SWIGTYPE_p_switch_core_session session, string app, string arg) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_execute_application(SWIGTYPE_p_switch_core_session.getCPtr(session), app, arg);
    return ret;
  }

  public static switch_status_t switch_core_session_execute_exten(SWIGTYPE_p_switch_core_session session, string exten, string dialplan, string context) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_execute_exten(SWIGTYPE_p_switch_core_session.getCPtr(session), exten, dialplan, context);
    return ret;
  }

  public static switch_status_t switch_core_session_receive_event(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_event arg1) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_receive_event(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_event.getCPtr(arg1));
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_session_get_private(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_private(SWIGTYPE_p_switch_core_session.getCPtr(session));
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_core_session_set_private(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_void private_info) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_set_private(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_void.getCPtr(private_info));
    return ret;
  }

  public static int switch_core_session_add_stream(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_void private_info) {
    int ret = freeswitchPINVOKE.switch_core_session_add_stream(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_void.getCPtr(private_info));
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_session_get_stream(SWIGTYPE_p_switch_core_session session, int index) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_stream(SWIGTYPE_p_switch_core_session.getCPtr(session), index);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static int switch_core_session_get_stream_count(SWIGTYPE_p_switch_core_session session) {
    int ret = freeswitchPINVOKE.switch_core_session_get_stream_count(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static void switch_core_session_launch_thread(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void func, SWIGTYPE_p_void obj) {
    freeswitchPINVOKE.switch_core_session_launch_thread(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void.getCPtr(func), SWIGTYPE_p_void.getCPtr(obj));
  }

  public static void switch_core_thread_session_end(switch_core_thread_session thread_session) {
    freeswitchPINVOKE.switch_core_thread_session_end(switch_core_thread_session.getCPtr(thread_session));
  }

  public static void switch_core_service_session(SWIGTYPE_p_switch_core_session session, switch_core_thread_session thread_session, int stream_id) {
    freeswitchPINVOKE.switch_core_service_session(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_core_thread_session.getCPtr(thread_session), stream_id);
  }

  public static switch_call_cause_t switch_core_session_outgoing_channel(SWIGTYPE_p_switch_core_session session, switch_event var_event, string endpoint_name, switch_caller_profile caller_profile, SWIGTYPE_p_p_switch_core_session new_session, SWIGTYPE_p_p_apr_pool_t pool, uint flags) {
    switch_call_cause_t ret = (switch_call_cause_t)freeswitchPINVOKE.switch_core_session_outgoing_channel(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_event.getCPtr(var_event), endpoint_name, switch_caller_profile.getCPtr(caller_profile), SWIGTYPE_p_p_switch_core_session.getCPtr(new_session), SWIGTYPE_p_p_apr_pool_t.getCPtr(pool), flags);
    return ret;
  }

  public static switch_call_cause_t switch_core_session_resurrect_channel(string endpoint_name, SWIGTYPE_p_p_switch_core_session new_session, SWIGTYPE_p_p_apr_pool_t pool, SWIGTYPE_p_void data) {
    switch_call_cause_t ret = (switch_call_cause_t)freeswitchPINVOKE.switch_core_session_resurrect_channel(endpoint_name, SWIGTYPE_p_p_switch_core_session.getCPtr(new_session), SWIGTYPE_p_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_void.getCPtr(data));
    return ret;
  }

  public static switch_status_t switch_core_session_receive_message(SWIGTYPE_p_switch_core_session session, switch_core_session_message message) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_receive_message(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_core_session_message.getCPtr(message));
    return ret;
  }

  public static switch_status_t switch_core_session_queue_event(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_event arg1) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_queue_event(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_event.getCPtr(arg1));
    return ret;
  }

  public static uint switch_core_session_event_count(SWIGTYPE_p_switch_core_session session) {
    uint ret = freeswitchPINVOKE.switch_core_session_event_count(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_core_session_dequeue_event(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_event arg1) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_dequeue_event(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_event.getCPtr(arg1));
    return ret;
  }

  public static switch_status_t switch_core_session_queue_private_event(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_event arg1) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_queue_private_event(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_event.getCPtr(arg1));
    return ret;
  }

  public static uint switch_core_session_private_event_count(SWIGTYPE_p_switch_core_session session) {
    uint ret = freeswitchPINVOKE.switch_core_session_private_event_count(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_core_session_dequeue_private_event(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_event arg1) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_dequeue_private_event(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_event.getCPtr(arg1));
    return ret;
  }

  public static uint switch_core_session_flush_private_events(SWIGTYPE_p_switch_core_session session) {
    uint ret = freeswitchPINVOKE.switch_core_session_flush_private_events(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_core_session_read_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_frame frame, uint flags, int stream_id) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_read_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_frame.getCPtr(frame), flags, stream_id);
    return ret;
  }

  public static switch_status_t switch_core_session_read_video_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_frame frame, uint flags, int stream_id) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_read_video_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_frame.getCPtr(frame), flags, stream_id);
    return ret;
  }

  public static switch_status_t switch_core_session_write_video_frame(SWIGTYPE_p_switch_core_session session, switch_frame frame, uint flags, int stream_id) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_write_video_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_frame.getCPtr(frame), flags, stream_id);
    return ret;
  }

  public static void switch_core_session_reset(SWIGTYPE_p_switch_core_session session, switch_bool_t flush_dtmf) {
    freeswitchPINVOKE.switch_core_session_reset(SWIGTYPE_p_switch_core_session.getCPtr(session), (int)flush_dtmf);
  }

  public static switch_status_t switch_core_session_write_frame(SWIGTYPE_p_switch_core_session session, switch_frame frame, uint flags, int stream_id) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_write_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_frame.getCPtr(frame), flags, stream_id);
    return ret;
  }

  public static switch_status_t switch_core_session_perform_kill_channel(SWIGTYPE_p_switch_core_session session, string file, string func, int line, switch_signal_t sig) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_perform_kill_channel(SWIGTYPE_p_switch_core_session.getCPtr(session), file, func, line, (int)sig);
    return ret;
  }

  public static switch_status_t switch_core_session_send_dtmf(SWIGTYPE_p_switch_core_session session, switch_dtmf_t dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_send_dtmf(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_dtmf_t.getCPtr(dtmf));
    return ret;
  }

  public static switch_status_t switch_core_session_send_dtmf_string(SWIGTYPE_p_switch_core_session session, string dtmf_string) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_send_dtmf_string(SWIGTYPE_p_switch_core_session.getCPtr(session), dtmf_string);
    return ret;
  }

  public static switch_status_t switch_core_session_recv_dtmf(SWIGTYPE_p_switch_core_session session, switch_dtmf_t dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_recv_dtmf(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_dtmf_t.getCPtr(dtmf));
    return ret;
  }

  public static switch_status_t switch_core_hash_init(SWIGTYPE_p_p_switch_hash hash, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_hash_init(SWIGTYPE_p_p_switch_hash.getCPtr(hash), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_hash_destroy(SWIGTYPE_p_p_switch_hash hash) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_hash_destroy(SWIGTYPE_p_p_switch_hash.getCPtr(hash));
    return ret;
  }

  public static switch_status_t switch_core_hash_insert(SWIGTYPE_p_switch_hash hash, string key, SWIGTYPE_p_void data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_hash_insert(SWIGTYPE_p_switch_hash.getCPtr(hash), key, SWIGTYPE_p_void.getCPtr(data));
    return ret;
  }

  public static switch_status_t switch_core_hash_insert_locked(SWIGTYPE_p_switch_hash hash, string key, SWIGTYPE_p_void data, SWIGTYPE_p_switch_mutex_t mutex) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_hash_insert_locked(SWIGTYPE_p_switch_hash.getCPtr(hash), key, SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_mutex_t.getCPtr(mutex));
    return ret;
  }

  public static switch_status_t switch_core_hash_delete(SWIGTYPE_p_switch_hash hash, string key) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_hash_delete(SWIGTYPE_p_switch_hash.getCPtr(hash), key);
    return ret;
  }

  public static switch_status_t switch_core_hash_delete_locked(SWIGTYPE_p_switch_hash hash, string key, SWIGTYPE_p_switch_mutex_t mutex) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_hash_delete_locked(SWIGTYPE_p_switch_hash.getCPtr(hash), key, SWIGTYPE_p_switch_mutex_t.getCPtr(mutex));
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_hash_find(SWIGTYPE_p_switch_hash hash, string key) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_hash_find(SWIGTYPE_p_switch_hash.getCPtr(hash), key);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_void switch_core_hash_find_locked(SWIGTYPE_p_switch_hash hash, string key, SWIGTYPE_p_switch_mutex_t mutex) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_hash_find_locked(SWIGTYPE_p_switch_hash.getCPtr(hash), key, SWIGTYPE_p_switch_mutex_t.getCPtr(mutex));
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_HashElem switch_hash_first(string depricate_me, SWIGTYPE_p_switch_hash hash) {
    IntPtr cPtr = freeswitchPINVOKE.switch_hash_first(depricate_me, SWIGTYPE_p_switch_hash.getCPtr(hash));
    SWIGTYPE_p_HashElem ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_HashElem(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_HashElem switch_hash_next(SWIGTYPE_p_HashElem hi) {
    IntPtr cPtr = freeswitchPINVOKE.switch_hash_next(SWIGTYPE_p_HashElem.getCPtr(hi));
    SWIGTYPE_p_HashElem ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_HashElem(cPtr, false);
    return ret;
  }

  public static void switch_hash_this(SWIGTYPE_p_HashElem hi, SWIGTYPE_p_p_void key, SWIGTYPE_p_switch_ssize_t klen, SWIGTYPE_p_p_void val) {
    freeswitchPINVOKE.switch_hash_this(SWIGTYPE_p_HashElem.getCPtr(hi), SWIGTYPE_p_p_void.getCPtr(key), SWIGTYPE_p_switch_ssize_t.getCPtr(klen), SWIGTYPE_p_p_void.getCPtr(val));
  }

  public static switch_status_t switch_core_timer_init(switch_timer timer, string timer_name, int interval, int samples, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_timer_init(switch_timer.getCPtr(timer), timer_name, interval, samples, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_timer_next(switch_timer timer) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_timer_next(switch_timer.getCPtr(timer));
    return ret;
  }

  public static switch_status_t switch_core_timer_step(switch_timer timer) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_timer_step(switch_timer.getCPtr(timer));
    return ret;
  }

  public static switch_status_t switch_core_timer_sync(switch_timer timer) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_timer_sync(switch_timer.getCPtr(timer));
    return ret;
  }

  public static switch_status_t switch_core_timer_check(switch_timer timer, switch_bool_t step) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_timer_check(switch_timer.getCPtr(timer), (int)step);
    return ret;
  }

  public static switch_status_t switch_core_timer_destroy(switch_timer timer) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_timer_destroy(switch_timer.getCPtr(timer));
    return ret;
  }

  public static switch_status_t switch_core_codec_init(switch_codec codec, string codec_name, string fmtp, uint rate, int ms, int channels, uint flags, switch_codec_settings codec_settings, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_init(switch_codec.getCPtr(codec), codec_name, fmtp, rate, ms, channels, flags, switch_codec_settings.getCPtr(codec_settings), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_codec_copy(switch_codec codec, switch_codec new_codec, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_copy(switch_codec.getCPtr(codec), switch_codec.getCPtr(new_codec), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_codec_encode(switch_codec codec, switch_codec other_codec, SWIGTYPE_p_void decoded_data, uint decoded_data_len, uint decoded_rate, SWIGTYPE_p_void encoded_data, SWIGTYPE_p_unsigned_long encoded_data_len, SWIGTYPE_p_unsigned_long encoded_rate, SWIGTYPE_p_unsigned_int flag) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_encode(switch_codec.getCPtr(codec), switch_codec.getCPtr(other_codec), SWIGTYPE_p_void.getCPtr(decoded_data), decoded_data_len, decoded_rate, SWIGTYPE_p_void.getCPtr(encoded_data), SWIGTYPE_p_unsigned_long.getCPtr(encoded_data_len), SWIGTYPE_p_unsigned_long.getCPtr(encoded_rate), SWIGTYPE_p_unsigned_int.getCPtr(flag));
    return ret;
  }

  public static switch_status_t switch_core_codec_decode(switch_codec codec, switch_codec other_codec, SWIGTYPE_p_void encoded_data, uint encoded_data_len, uint encoded_rate, SWIGTYPE_p_void decoded_data, SWIGTYPE_p_unsigned_long decoded_data_len, SWIGTYPE_p_unsigned_long decoded_rate, SWIGTYPE_p_unsigned_int flag) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_decode(switch_codec.getCPtr(codec), switch_codec.getCPtr(other_codec), SWIGTYPE_p_void.getCPtr(encoded_data), encoded_data_len, encoded_rate, SWIGTYPE_p_void.getCPtr(decoded_data), SWIGTYPE_p_unsigned_long.getCPtr(decoded_data_len), SWIGTYPE_p_unsigned_long.getCPtr(decoded_rate), SWIGTYPE_p_unsigned_int.getCPtr(flag));
    return ret;
  }

  public static switch_status_t switch_core_codec_destroy(switch_codec codec) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_codec_destroy(switch_codec.getCPtr(codec));
    return ret;
  }

  public static switch_status_t switch_core_session_set_read_codec(SWIGTYPE_p_switch_core_session session, switch_codec codec) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_set_read_codec(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_codec.getCPtr(codec));
    return ret;
  }

  public static switch_codec switch_core_session_get_read_codec(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_read_codec(SWIGTYPE_p_switch_core_session.getCPtr(session));
    switch_codec ret = (cPtr == IntPtr.Zero) ? null : new switch_codec(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_core_session_set_write_codec(SWIGTYPE_p_switch_core_session session, switch_codec codec) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_set_write_codec(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_codec.getCPtr(codec));
    return ret;
  }

  public static switch_codec switch_core_session_get_write_codec(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_write_codec(SWIGTYPE_p_switch_core_session.getCPtr(session));
    switch_codec ret = (cPtr == IntPtr.Zero) ? null : new switch_codec(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_core_session_set_video_read_codec(SWIGTYPE_p_switch_core_session session, switch_codec codec) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_set_video_read_codec(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_codec.getCPtr(codec));
    return ret;
  }

  public static switch_codec switch_core_session_get_video_read_codec(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_video_read_codec(SWIGTYPE_p_switch_core_session.getCPtr(session));
    switch_codec ret = (cPtr == IntPtr.Zero) ? null : new switch_codec(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_core_session_set_video_write_codec(SWIGTYPE_p_switch_core_session session, switch_codec codec) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_session_set_video_write_codec(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_codec.getCPtr(codec));
    return ret;
  }

  public static switch_codec switch_core_session_get_video_write_codec(SWIGTYPE_p_switch_core_session session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_session_get_video_write_codec(SWIGTYPE_p_switch_core_session.getCPtr(session));
    switch_codec ret = (cPtr == IntPtr.Zero) ? null : new switch_codec(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_sqlite3 switch_core_db_open_file(string filename) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_db_open_file(filename);
    SWIGTYPE_p_sqlite3 ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_sqlite3(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_core_db_persistant_execute(SWIGTYPE_p_sqlite3 db, string sql, uint retries) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_db_persistant_execute(SWIGTYPE_p_sqlite3.getCPtr(db), sql, retries);
    return ret;
  }

  public static void switch_core_db_test_reactive(SWIGTYPE_p_sqlite3 db, string test_sql, string drop_sql, string reactive_sql) {
    freeswitchPINVOKE.switch_core_db_test_reactive(SWIGTYPE_p_sqlite3.getCPtr(db), test_sql, drop_sql, reactive_sql);
  }

  public static switch_status_t switch_core_perform_file_open(string file, string func, int line, switch_file_handle fh, string file_path, byte channels, uint rate, uint flags, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_perform_file_open(file, func, line, switch_file_handle.getCPtr(fh), file_path, channels, rate, flags, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_file_read(switch_file_handle fh, SWIGTYPE_p_void data, SWIGTYPE_p_switch_size_t len) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_file_read(switch_file_handle.getCPtr(fh), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(len));
    return ret;
  }

  public static switch_status_t switch_core_file_write(switch_file_handle fh, SWIGTYPE_p_void data, SWIGTYPE_p_switch_size_t len) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_file_write(switch_file_handle.getCPtr(fh), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(len));
    return ret;
  }

  public static switch_status_t switch_core_file_seek(switch_file_handle fh, SWIGTYPE_p_unsigned_int cur_pos, long samples, int whence) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_file_seek(switch_file_handle.getCPtr(fh), SWIGTYPE_p_unsigned_int.getCPtr(cur_pos), samples, whence);
    return ret;
  }

  public static switch_status_t switch_core_file_set_string(switch_file_handle fh, switch_audio_col_t col, string arg2) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_file_set_string(switch_file_handle.getCPtr(fh), (int)col, arg2);
    return ret;
  }

  public static switch_status_t switch_core_file_get_string(switch_file_handle fh, switch_audio_col_t col, SWIGTYPE_p_p_char arg2) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_file_get_string(switch_file_handle.getCPtr(fh), (int)col, SWIGTYPE_p_p_char.getCPtr(arg2));
    return ret;
  }

  public static switch_status_t switch_core_file_close(switch_file_handle fh) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_file_close(switch_file_handle.getCPtr(fh));
    return ret;
  }

  public static switch_status_t switch_core_speech_open(switch_speech_handle sh, string module_name, string voice_name, uint rate, uint interval, SWIGTYPE_p_unsigned_long flags, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_speech_open(switch_speech_handle.getCPtr(sh), module_name, voice_name, rate, interval, SWIGTYPE_p_unsigned_long.getCPtr(flags), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_speech_feed_tts(switch_speech_handle sh, string text, SWIGTYPE_p_unsigned_long flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_speech_feed_tts(switch_speech_handle.getCPtr(sh), text, SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static void switch_core_speech_flush_tts(switch_speech_handle sh) {
    freeswitchPINVOKE.switch_core_speech_flush_tts(switch_speech_handle.getCPtr(sh));
  }

  public static void switch_core_speech_text_param_tts(switch_speech_handle sh, string param, string val) {
    freeswitchPINVOKE.switch_core_speech_text_param_tts(switch_speech_handle.getCPtr(sh), param, val);
  }

  public static void switch_core_speech_numeric_param_tts(switch_speech_handle sh, string param, int val) {
    freeswitchPINVOKE.switch_core_speech_numeric_param_tts(switch_speech_handle.getCPtr(sh), param, val);
  }

  public static void switch_core_speech_float_param_tts(switch_speech_handle sh, string param, double val) {
    freeswitchPINVOKE.switch_core_speech_float_param_tts(switch_speech_handle.getCPtr(sh), param, val);
  }

  public static switch_status_t switch_core_speech_read_tts(switch_speech_handle sh, SWIGTYPE_p_void data, SWIGTYPE_p_switch_size_t datalen, SWIGTYPE_p_unsigned_long rate, SWIGTYPE_p_unsigned_long flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_speech_read_tts(switch_speech_handle.getCPtr(sh), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(datalen), SWIGTYPE_p_unsigned_long.getCPtr(rate), SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static switch_status_t switch_core_speech_close(switch_speech_handle sh, SWIGTYPE_p_unsigned_long flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_speech_close(switch_speech_handle.getCPtr(sh), SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static switch_status_t switch_core_asr_open(switch_asr_handle ah, string module_name, string codec, int rate, string dest, SWIGTYPE_p_unsigned_long flags, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_open(switch_asr_handle.getCPtr(ah), module_name, codec, rate, dest, SWIGTYPE_p_unsigned_long.getCPtr(flags), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_asr_close(switch_asr_handle ah, SWIGTYPE_p_unsigned_long flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_close(switch_asr_handle.getCPtr(ah), SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static switch_status_t switch_core_asr_feed(switch_asr_handle ah, SWIGTYPE_p_void data, uint len, SWIGTYPE_p_unsigned_long flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_feed(switch_asr_handle.getCPtr(ah), SWIGTYPE_p_void.getCPtr(data), len, SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static switch_status_t switch_core_asr_check_results(switch_asr_handle ah, SWIGTYPE_p_unsigned_long flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_check_results(switch_asr_handle.getCPtr(ah), SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static switch_status_t switch_core_asr_get_results(switch_asr_handle ah, SWIGTYPE_p_p_char xmlstr, SWIGTYPE_p_unsigned_long flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_get_results(switch_asr_handle.getCPtr(ah), SWIGTYPE_p_p_char.getCPtr(xmlstr), SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static switch_status_t switch_core_asr_load_grammar(switch_asr_handle ah, string grammar, string path) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_load_grammar(switch_asr_handle.getCPtr(ah), grammar, path);
    return ret;
  }

  public static switch_status_t switch_core_asr_unload_grammar(switch_asr_handle ah, string grammar) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_unload_grammar(switch_asr_handle.getCPtr(ah), grammar);
    return ret;
  }

  public static switch_status_t switch_core_asr_pause(switch_asr_handle ah) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_pause(switch_asr_handle.getCPtr(ah));
    return ret;
  }

  public static switch_status_t switch_core_asr_resume(switch_asr_handle ah) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_asr_resume(switch_asr_handle.getCPtr(ah));
    return ret;
  }

  public static switch_status_t switch_core_directory_open(switch_directory_handle dh, string module_name, string source, string dsn, string passwd, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_directory_open(switch_directory_handle.getCPtr(dh), module_name, source, dsn, passwd, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_core_directory_query(switch_directory_handle dh, string arg1, string query) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_directory_query(switch_directory_handle.getCPtr(dh), arg1, query);
    return ret;
  }

  public static switch_status_t switch_core_directory_next(switch_directory_handle dh) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_directory_next(switch_directory_handle.getCPtr(dh));
    return ret;
  }

  public static switch_status_t switch_core_directory_next_pair(switch_directory_handle dh, SWIGTYPE_p_p_char var, SWIGTYPE_p_p_char val) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_directory_next_pair(switch_directory_handle.getCPtr(dh), SWIGTYPE_p_p_char.getCPtr(var), SWIGTYPE_p_p_char.getCPtr(val));
    return ret;
  }

  public static switch_status_t switch_core_directory_close(switch_directory_handle dh) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_directory_close(switch_directory_handle.getCPtr(dh));
    return ret;
  }

  public static SWIGTYPE_p_FILE switch_core_data_channel(switch_text_channel_t channel) {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_data_channel((int)channel);
    SWIGTYPE_p_FILE ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_FILE(cPtr, false);
    return ret;
  }

  public static switch_bool_t switch_core_ready() {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_core_ready();
    return ret;
  }

  public static uint switch_core_flags() {
    uint ret = freeswitchPINVOKE.switch_core_flags();
    return ret;
  }

  public static switch_status_t switch_core_management_exec(string relative_oid, switch_management_action_t action, string data, SWIGTYPE_p_switch_size_t datalen) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_management_exec(relative_oid, (int)action, data, SWIGTYPE_p_switch_size_t.getCPtr(datalen));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static int set_high_priority() {
    int ret = freeswitchPINVOKE.set_high_priority();
    return ret;
  }

  public static int change_user_group(string user, string group) {
    int ret = freeswitchPINVOKE.change_user_group(user, group);
    return ret;
  }

  public static void switch_core_runtime_loop(int bg) {
    freeswitchPINVOKE.switch_core_runtime_loop(bg);
  }

  public static switch_status_t switch_core_set_console(string console) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_set_console(console);
    return ret;
  }

  public static void switch_core_measure_time(SWIGTYPE_p_switch_time_t total_ms, switch_core_time_duration duration) {
    freeswitchPINVOKE.switch_core_measure_time(SWIGTYPE_p_switch_time_t.getCPtr(total_ms), switch_core_time_duration.getCPtr(duration));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
  }

  public static SWIGTYPE_p_switch_time_t switch_core_uptime() {
    SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_core_uptime(), true);
    return ret;
  }

  public static int switch_core_session_ctl(switch_session_ctl_t cmd, SWIGTYPE_p_int val) {
    int ret = freeswitchPINVOKE.switch_core_session_ctl((int)cmd, SWIGTYPE_p_int.getCPtr(val));
    return ret;
  }

  public static SWIGTYPE_p_FILE switch_core_get_console() {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_get_console();
    SWIGTYPE_p_FILE ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_FILE(cPtr, false);
    return ret;
  }

  public static void switch_core_launch_thread(SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void func, SWIGTYPE_p_void obj, SWIGTYPE_p_apr_pool_t pool) {
    freeswitchPINVOKE.switch_core_launch_thread(SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void.getCPtr(func), SWIGTYPE_p_void.getCPtr(obj), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
  }

  public static void switch_core_set_globals() {
    freeswitchPINVOKE.switch_core_set_globals();
  }

  public static byte switch_core_session_compare(SWIGTYPE_p_switch_core_session a, SWIGTYPE_p_switch_core_session b) {
    byte ret = freeswitchPINVOKE.switch_core_session_compare(SWIGTYPE_p_switch_core_session.getCPtr(a), SWIGTYPE_p_switch_core_session.getCPtr(b));
    return ret;
  }

  public static SWIGTYPE_p_HashElem switch_core_mime_index() {
    IntPtr cPtr = freeswitchPINVOKE.switch_core_mime_index();
    SWIGTYPE_p_HashElem ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_HashElem(cPtr, false);
    return ret;
  }

  public static string switch_core_mime_ext2type(string ext) {
    string ret = freeswitchPINVOKE.switch_core_mime_ext2type(ext);
    return ret;
  }

  public static switch_status_t switch_core_mime_add_type(string type, string ext) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_mime_add_type(type, ext);
    return ret;
  }

  public static SWIGTYPE_p_switch_loadable_module_interface switch_loadable_module_create_module_interface(SWIGTYPE_p_apr_pool_t pool, string name) {
    IntPtr cPtr = freeswitchPINVOKE.switch_loadable_module_create_module_interface(SWIGTYPE_p_apr_pool_t.getCPtr(pool), name);
    SWIGTYPE_p_switch_loadable_module_interface ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_loadable_module_interface(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_void switch_loadable_module_create_interface(SWIGTYPE_p_switch_loadable_module_interface mod, switch_module_interface_name_t iname) {
    IntPtr cPtr = freeswitchPINVOKE.switch_loadable_module_create_interface(SWIGTYPE_p_switch_loadable_module_interface.getCPtr(mod), (int)iname);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static SWIGTYPE_p_switch_time_t switch_timestamp_now() {
    SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_timestamp_now(), true);
    return ret;
  }

  public static void switch_core_memory_reclaim() {
    freeswitchPINVOKE.switch_core_memory_reclaim();
  }

  public static void switch_core_memory_reclaim_events() {
    freeswitchPINVOKE.switch_core_memory_reclaim_events();
  }

  public static void switch_core_memory_reclaim_logger() {
    freeswitchPINVOKE.switch_core_memory_reclaim_logger();
  }

  public static void switch_core_memory_reclaim_all() {
    freeswitchPINVOKE.switch_core_memory_reclaim_all();
  }

  public static void switch_core_setrlimits() {
    freeswitchPINVOKE.switch_core_setrlimits();
  }

  public static void switch_time_sync() {
    freeswitchPINVOKE.switch_time_sync();
  }

  public static SWIGTYPE_p_time_t switch_timestamp(SWIGTYPE_p_time_t t) {
    SWIGTYPE_p_time_t ret = new SWIGTYPE_p_time_t(freeswitchPINVOKE.switch_timestamp(SWIGTYPE_p_time_t.getCPtr(t)), true);
    return ret;
  }

  public static void switch_load_network_lists(switch_bool_t reload) {
    freeswitchPINVOKE.switch_load_network_lists((int)reload);
  }

  public static switch_bool_t switch_check_network_list_ip(string ip_str, string list_name) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_check_network_list_ip(ip_str, list_name);
    return ret;
  }

  public static void switch_time_set_monotonic(switch_bool_t enable) {
    freeswitchPINVOKE.switch_time_set_monotonic((int)enable);
  }

  public static uint switch_core_max_dtmf_duration(uint duration) {
    uint ret = freeswitchPINVOKE.switch_core_max_dtmf_duration(duration);
    return ret;
  }

  public static uint switch_core_default_dtmf_duration(uint duration) {
    uint ret = freeswitchPINVOKE.switch_core_default_dtmf_duration(duration);
    return ret;
  }

  public static switch_status_t switch_console_set_complete(string arg0) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_console_set_complete(arg0);
    return ret;
  }

  public static switch_status_t switch_console_set_alias(string arg0) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_console_set_alias(arg0);
    return ret;
  }

  public static void switch_console_loop() {
    freeswitchPINVOKE.switch_console_loop();
  }

  public static switch_status_t switch_console_stream_raw_write(switch_stream_handle handle, SWIGTYPE_p_unsigned_char data, SWIGTYPE_p_switch_size_t datalen) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_console_stream_raw_write(switch_stream_handle.getCPtr(handle), SWIGTYPE_p_unsigned_char.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(datalen));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_bool_t switch_is_moh(string s) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_is_moh(s);
    return ret;
  }

  public static switch_status_t switch_b64_encode(SWIGTYPE_p_unsigned_char arg0, SWIGTYPE_p_switch_size_t ilen, SWIGTYPE_p_unsigned_char arg2, SWIGTYPE_p_switch_size_t olen) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_b64_encode(SWIGTYPE_p_unsigned_char.getCPtr(arg0), SWIGTYPE_p_switch_size_t.getCPtr(ilen), SWIGTYPE_p_unsigned_char.getCPtr(arg2), SWIGTYPE_p_switch_size_t.getCPtr(olen));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_b64_decode(string arg0, string arg1, SWIGTYPE_p_switch_size_t olen) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_b64_decode(arg0, arg1, SWIGTYPE_p_switch_size_t.getCPtr(olen)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static string switch_amp_encode(string s, string buf, SWIGTYPE_p_switch_size_t len) {
    string ret = freeswitchPINVOKE.switch_amp_encode(s, buf, SWIGTYPE_p_switch_size_t.getCPtr(len));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_bool_t switch_is_digit_string(string s) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_is_digit_string(s);
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_fd_read_line(int fd, string buf, SWIGTYPE_p_switch_size_t len) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_fd_read_line(fd, buf, SWIGTYPE_p_switch_size_t.getCPtr(len)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_status_t switch_find_local_ip(string buf, int len, int family) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_find_local_ip(buf, len, family);
    return ret;
  }

  public static string get_addr(string buf, SWIGTYPE_p_switch_size_t len, SWIGTYPE_p_in_addr arg2) {
    string ret = freeswitchPINVOKE.get_addr(buf, SWIGTYPE_p_switch_size_t.getCPtr(len), SWIGTYPE_p_in_addr.getCPtr(arg2));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static string switch_priority_name(switch_priority_t priority) {
    string ret = freeswitchPINVOKE.switch_priority_name((int)priority);
    return ret;
  }

  public static char switch_rfc2833_to_char(int arg0) {
    char ret = freeswitchPINVOKE.switch_rfc2833_to_char(arg0);
    return ret;
  }

  public static byte switch_char_to_rfc2833(char key) {
    byte ret = freeswitchPINVOKE.switch_char_to_rfc2833(key);
    return ret;
  }

  public static string switch_clean_string(string s) {
    string ret = freeswitchPINVOKE.switch_clean_string(s);
    return ret;
  }

  public static switch_bool_t switch_strstr(string s, string q) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_strstr(s, q);
    return ret;
  }

  public static SWIGTYPE_p_switch_time_t switch_str_time(string arg0) {
    SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_str_time(arg0), true);
    return ret;
  }

  public static uint switch_separate_string(string buf, char delim, SWIGTYPE_p_p_char array, uint arraylen) {
    uint ret = freeswitchPINVOKE.switch_separate_string(buf, delim, SWIGTYPE_p_p_char.getCPtr(array), arraylen);
    return ret;
  }

  public static switch_bool_t switch_is_number(string str) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_is_number(str);
    return ret;
  }

  public static string switch_strip_spaces(string str) {
    string ret = freeswitchPINVOKE.switch_strip_spaces(str);
    return ret;
  }

  public static string switch_separate_paren_args(string str) {
    string ret = freeswitchPINVOKE.switch_separate_paren_args(str);
    return ret;
  }

  public static string switch_stristr(string instr, string str) {
    string ret = freeswitchPINVOKE.switch_stristr(instr, str);
    return ret;
  }

  public static switch_bool_t switch_is_lan_addr(string ip) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_is_lan_addr(ip);
    return ret;
  }

  public static string switch_replace_char(string str, char from, char to, switch_bool_t dup) {
    string ret = freeswitchPINVOKE.switch_replace_char(str, from, to, (int)dup);
    return ret;
  }

  public static switch_bool_t switch_ast2regex(string pat, string rbuf, uint len) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_ast2regex(pat, rbuf, len);
    return ret;
  }

  public static string switch_escape_char(SWIGTYPE_p_apr_pool_t pool, string arg1, string delim, char esc) {
    string ret = freeswitchPINVOKE.switch_escape_char(SWIGTYPE_p_apr_pool_t.getCPtr(pool), arg1, delim, esc);
    return ret;
  }

  public static int switch_socket_waitfor(SWIGTYPE_p_switch_pollfd_t poll, int ms) {
    int ret = freeswitchPINVOKE.switch_socket_waitfor(SWIGTYPE_p_switch_pollfd_t.getCPtr(poll), ms);
    return ret;
  }

  public static string switch_cut_path(string arg0) {
    string ret = freeswitchPINVOKE.switch_cut_path(arg0);
    return ret;
  }

  public static string switch_string_replace(string arg0, string search, string replace) {
    string ret = freeswitchPINVOKE.switch_string_replace(arg0, search, replace);
    return ret;
  }

  public static switch_status_t switch_string_match(string arg0, uint string_len, string search, uint search_len) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_string_match(arg0, string_len, search, search_len);
    return ret;
  }

  public static uint switch_url_encode(string url, string buf, uint len) {
    uint ret = freeswitchPINVOKE.switch_url_encode(url, buf, len);
    return ret;
  }

  public static string switch_url_decode(string s) {
    string ret = freeswitchPINVOKE.switch_url_decode(s);
    return ret;
  }

  public static switch_bool_t switch_simple_email(string to, string from, string headers, string body, string file) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_simple_email(to, from, headers, body, file);
    return ret;
  }

  public static string switch_find_end_paren(string s, char open, char close) {
    string ret = freeswitchPINVOKE.switch_find_end_paren(s, open, close);
    return ret;
  }

  public static int switch_parse_cidr(string arg0, SWIGTYPE_p_unsigned_long ip, SWIGTYPE_p_unsigned_long mask, SWIGTYPE_p_unsigned_long bitp) {
    int ret = freeswitchPINVOKE.switch_parse_cidr(arg0, SWIGTYPE_p_unsigned_long.getCPtr(ip), SWIGTYPE_p_unsigned_long.getCPtr(mask), SWIGTYPE_p_unsigned_long.getCPtr(bitp));
    return ret;
  }

  public static switch_status_t switch_network_list_create(SWIGTYPE_p_p_switch_network_list list, switch_bool_t default_type, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_network_list_create(SWIGTYPE_p_p_switch_network_list.getCPtr(list), (int)default_type, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_network_list_add_cidr(SWIGTYPE_p_switch_network_list list, string cidr_str, switch_bool_t ok) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_network_list_add_cidr(SWIGTYPE_p_switch_network_list.getCPtr(list), cidr_str, (int)ok);
    return ret;
  }

  public static switch_status_t switch_network_list_add_host_mask(SWIGTYPE_p_switch_network_list list, string host, string mask_str, switch_bool_t ok) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_network_list_add_host_mask(SWIGTYPE_p_switch_network_list.getCPtr(list), host, mask_str, (int)ok);
    return ret;
  }

  public static switch_bool_t switch_network_list_validate_ip(SWIGTYPE_p_switch_network_list list, uint ip) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_network_list_validate_ip(SWIGTYPE_p_switch_network_list.getCPtr(list), ip);
    return ret;
  }

  public static switch_caller_extension switch_caller_extension_new(SWIGTYPE_p_switch_core_session session, string extension_name, string extension_number) {
    IntPtr cPtr = freeswitchPINVOKE.switch_caller_extension_new(SWIGTYPE_p_switch_core_session.getCPtr(session), extension_name, extension_number);
    switch_caller_extension ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_extension(cPtr, false);
    return ret;
  }

  public static void switch_caller_extension_add_application(SWIGTYPE_p_switch_core_session session, switch_caller_extension caller_extension, string application_name, string extra_data) {
    freeswitchPINVOKE.switch_caller_extension_add_application(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_caller_extension.getCPtr(caller_extension), application_name, extra_data);
  }

  public static string switch_caller_get_field_by_name(switch_caller_profile caller_profile, string name) {
    string ret = freeswitchPINVOKE.switch_caller_get_field_by_name(switch_caller_profile.getCPtr(caller_profile), name);
    return ret;
  }

  public static switch_caller_profile switch_caller_profile_new(SWIGTYPE_p_apr_pool_t pool, string username, string dialplan, string caller_id_name, string caller_id_number, string network_addr, string ani, string aniii, string rdnis, string source, string context, string destination_number) {
    IntPtr cPtr = freeswitchPINVOKE.switch_caller_profile_new(SWIGTYPE_p_apr_pool_t.getCPtr(pool), username, dialplan, caller_id_name, caller_id_number, network_addr, ani, aniii, rdnis, source, context, destination_number);
    switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
    return ret;
  }

  public static switch_caller_profile switch_caller_profile_clone(SWIGTYPE_p_switch_core_session session, switch_caller_profile tocopy) {
    IntPtr cPtr = freeswitchPINVOKE.switch_caller_profile_clone(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_caller_profile.getCPtr(tocopy));
    switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
    return ret;
  }

  public static switch_caller_profile switch_caller_profile_dup(SWIGTYPE_p_apr_pool_t pool, switch_caller_profile tocopy) {
    IntPtr cPtr = freeswitchPINVOKE.switch_caller_profile_dup(SWIGTYPE_p_apr_pool_t.getCPtr(pool), switch_caller_profile.getCPtr(tocopy));
    switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
    return ret;
  }

  public static void switch_caller_profile_event_set_data(switch_caller_profile caller_profile, string prefix, switch_event arg2) {
    freeswitchPINVOKE.switch_caller_profile_event_set_data(switch_caller_profile.getCPtr(caller_profile), prefix, switch_event.getCPtr(arg2));
  }

  public static switch_channel_state_t switch_channel_get_state(SWIGTYPE_p_switch_channel channel) {
    switch_channel_state_t ret = (switch_channel_state_t)freeswitchPINVOKE.switch_channel_get_state(SWIGTYPE_p_switch_channel.getCPtr(channel));
    return ret;
  }

  public static switch_channel_state_t switch_channel_get_running_state(SWIGTYPE_p_switch_channel channel) {
    switch_channel_state_t ret = (switch_channel_state_t)freeswitchPINVOKE.switch_channel_get_running_state(SWIGTYPE_p_switch_channel.getCPtr(channel));
    return ret;
  }

  public static byte switch_channel_ready(SWIGTYPE_p_switch_channel channel) {
    byte ret = freeswitchPINVOKE.switch_channel_ready(SWIGTYPE_p_switch_channel.getCPtr(channel));
    return ret;
  }

  public static void switch_channel_wait_for_state(SWIGTYPE_p_switch_channel channel, SWIGTYPE_p_switch_channel other_channel, switch_channel_state_t want_state) {
    freeswitchPINVOKE.switch_channel_wait_for_state(SWIGTYPE_p_switch_channel.getCPtr(channel), SWIGTYPE_p_switch_channel.getCPtr(other_channel), (int)want_state);
  }

  public static switch_status_t switch_channel_wait_for_flag(SWIGTYPE_p_switch_channel channel, uint want_flag, switch_bool_t pres, uint to) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_wait_for_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), want_flag, (int)pres, to);
    return ret;
  }

  public static switch_channel_state_t switch_channel_perform_set_state(SWIGTYPE_p_switch_channel channel, string file, string func, int line, switch_channel_state_t state) {
    switch_channel_state_t ret = (switch_channel_state_t)freeswitchPINVOKE.switch_channel_perform_set_state(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line, (int)state);
    return ret;
  }

  public static switch_channel_state_t switch_channel_perform_set_running_state(SWIGTYPE_p_switch_channel channel, switch_channel_state_t state, string file, string func, int line) {
    switch_channel_state_t ret = (switch_channel_state_t)freeswitchPINVOKE.switch_channel_perform_set_running_state(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)state, file, func, line);
    return ret;
  }

  public static switch_call_cause_t switch_channel_str2cause(string str) {
    switch_call_cause_t ret = (switch_call_cause_t)freeswitchPINVOKE.switch_channel_str2cause(str);
    return ret;
  }

  public static switch_call_cause_t switch_channel_get_cause(SWIGTYPE_p_switch_channel channel) {
    switch_call_cause_t ret = (switch_call_cause_t)freeswitchPINVOKE.switch_channel_get_cause(SWIGTYPE_p_switch_channel.getCPtr(channel));
    return ret;
  }

  public static string switch_channel_cause2str(switch_call_cause_t cause) {
    string ret = freeswitchPINVOKE.switch_channel_cause2str((int)cause);
    return ret;
  }

  public static switch_channel_timetable switch_channel_get_timetable(SWIGTYPE_p_switch_channel channel) {
    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_timetable(SWIGTYPE_p_switch_channel.getCPtr(channel));
    switch_channel_timetable ret = (cPtr == IntPtr.Zero) ? null : new switch_channel_timetable(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_channel_alloc(SWIGTYPE_p_p_switch_channel channel, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_alloc(SWIGTYPE_p_p_switch_channel.getCPtr(channel), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_channel_init(SWIGTYPE_p_switch_channel channel, SWIGTYPE_p_switch_core_session session, switch_channel_state_t state, uint flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_init(SWIGTYPE_p_switch_channel.getCPtr(channel), SWIGTYPE_p_switch_core_session.getCPtr(session), (int)state, flags);
    return ret;
  }

  public static void switch_channel_presence(SWIGTYPE_p_switch_channel channel, string rpid, string status) {
    freeswitchPINVOKE.switch_channel_presence(SWIGTYPE_p_switch_channel.getCPtr(channel), rpid, status);
  }

  public static void switch_channel_uninit(SWIGTYPE_p_switch_channel channel) {
    freeswitchPINVOKE.switch_channel_uninit(SWIGTYPE_p_switch_channel.getCPtr(channel));
  }

  public static void switch_channel_set_caller_profile(SWIGTYPE_p_switch_channel channel, switch_caller_profile caller_profile) {
    freeswitchPINVOKE.switch_channel_set_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_profile.getCPtr(caller_profile));
  }

  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);
    return ret;
  }

  public static void switch_channel_set_originator_caller_profile(SWIGTYPE_p_switch_channel channel, switch_caller_profile caller_profile) {
    freeswitchPINVOKE.switch_channel_set_originator_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_profile.getCPtr(caller_profile));
  }

  public static switch_caller_profile switch_channel_get_originator_caller_profile(SWIGTYPE_p_switch_channel channel) {
    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_originator_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel));
    switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
    return ret;
  }

  public static void switch_channel_set_originatee_caller_profile(SWIGTYPE_p_switch_channel channel, switch_caller_profile caller_profile) {
    freeswitchPINVOKE.switch_channel_set_originatee_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_profile.getCPtr(caller_profile));
  }

  public static switch_caller_profile switch_channel_get_originatee_caller_profile(SWIGTYPE_p_switch_channel channel) {
    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_originatee_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel));
    switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
    return ret;
  }

  public static string switch_channel_get_uuid(SWIGTYPE_p_switch_channel channel) {
    string ret = freeswitchPINVOKE.switch_channel_get_uuid(SWIGTYPE_p_switch_channel.getCPtr(channel));
    return ret;
  }

  public static switch_status_t switch_channel_set_variable(SWIGTYPE_p_switch_channel channel, string varname, string value) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_set_variable(SWIGTYPE_p_switch_channel.getCPtr(channel), varname, value);
    return ret;
  }

  public static switch_status_t switch_channel_set_variable_partner(SWIGTYPE_p_switch_channel channel, string varname, string value) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_set_variable_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), varname, value);
    return ret;
  }

  public static string switch_channel_get_variable_partner(SWIGTYPE_p_switch_channel channel, string varname) {
    string ret = freeswitchPINVOKE.switch_channel_get_variable_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), varname);
    return ret;
  }

  public static string switch_channel_get_variable(SWIGTYPE_p_switch_channel channel, string varname) {
    string ret = freeswitchPINVOKE.switch_channel_get_variable(SWIGTYPE_p_switch_channel.getCPtr(channel), varname);
    return ret;
  }

  public static switch_event_header switch_channel_variable_first(SWIGTYPE_p_switch_channel channel) {
    IntPtr cPtr = freeswitchPINVOKE.switch_channel_variable_first(SWIGTYPE_p_switch_channel.getCPtr(channel));
    switch_event_header ret = (cPtr == IntPtr.Zero) ? null : new switch_event_header(cPtr, false);
    return ret;
  }

  public static void switch_channel_variable_last(SWIGTYPE_p_switch_channel channel) {
    freeswitchPINVOKE.switch_channel_variable_last(SWIGTYPE_p_switch_channel.getCPtr(channel));
  }

  public static void switch_channel_set_caller_extension(SWIGTYPE_p_switch_channel channel, switch_caller_extension caller_extension) {
    freeswitchPINVOKE.switch_channel_set_caller_extension(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_extension.getCPtr(caller_extension));
  }

  public static switch_caller_extension switch_channel_get_caller_extension(SWIGTYPE_p_switch_channel channel) {
    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_caller_extension(SWIGTYPE_p_switch_channel.getCPtr(channel));
    switch_caller_extension ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_extension(cPtr, false);
    return ret;
  }

  public static uint switch_channel_test_flag(SWIGTYPE_p_switch_channel channel, uint flags) {
    uint ret = freeswitchPINVOKE.switch_channel_test_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags);
    return ret;
  }

  public static void switch_channel_set_flag(SWIGTYPE_p_switch_channel channel, uint flags) {
    freeswitchPINVOKE.switch_channel_set_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags);
  }

  public static switch_bool_t switch_channel_set_flag_partner(SWIGTYPE_p_switch_channel channel, uint flags) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_channel_set_flag_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), flags);
    return ret;
  }

  public static switch_bool_t switch_channel_clear_flag_partner(SWIGTYPE_p_switch_channel channel, uint flags) {
    switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_channel_clear_flag_partner(SWIGTYPE_p_switch_channel.getCPtr(channel), flags);
    return ret;
  }

  public static void switch_channel_set_state_flag(SWIGTYPE_p_switch_channel channel, uint flags) {
    freeswitchPINVOKE.switch_channel_set_state_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags);
  }

  public static void switch_channel_clear_flag(SWIGTYPE_p_switch_channel channel, uint flags) {
    freeswitchPINVOKE.switch_channel_clear_flag(SWIGTYPE_p_switch_channel.getCPtr(channel), flags);
  }

  public static switch_status_t switch_channel_perform_answer(SWIGTYPE_p_switch_channel channel, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_perform_answer(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line);
    return ret;
  }

  public static switch_status_t switch_channel_perform_mark_answered(SWIGTYPE_p_switch_channel channel, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_perform_mark_answered(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line);
    return ret;
  }

  public static switch_status_t switch_channel_perform_ring_ready(SWIGTYPE_p_switch_channel channel, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_perform_ring_ready(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line);
    return ret;
  }

  public static switch_status_t switch_channel_perform_pre_answer(SWIGTYPE_p_switch_channel channel, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_perform_pre_answer(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line);
    return ret;
  }

  public static switch_status_t switch_channel_perform_mark_pre_answered(SWIGTYPE_p_switch_channel channel, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_perform_mark_pre_answered(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line);
    return ret;
  }

  public static switch_status_t switch_channel_perform_mark_ring_ready(SWIGTYPE_p_switch_channel channel, string file, string func, int line) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_perform_mark_ring_ready(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line);
    return ret;
  }

  public static int switch_channel_add_state_handler(SWIGTYPE_p_switch_channel channel, switch_state_handler_table state_handler) {
    int ret = freeswitchPINVOKE.switch_channel_add_state_handler(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_state_handler_table.getCPtr(state_handler));
    return ret;
  }

  public static void switch_channel_clear_state_handler(SWIGTYPE_p_switch_channel channel, switch_state_handler_table state_handler) {
    freeswitchPINVOKE.switch_channel_clear_state_handler(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_state_handler_table.getCPtr(state_handler));
  }

  public static switch_state_handler_table switch_channel_get_state_handler(SWIGTYPE_p_switch_channel channel, int index) {
    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_state_handler(SWIGTYPE_p_switch_channel.getCPtr(channel), index);
    switch_state_handler_table ret = (cPtr == IntPtr.Zero) ? null : new switch_state_handler_table(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_channel_set_private(SWIGTYPE_p_switch_channel channel, string key, SWIGTYPE_p_void private_info) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_set_private(SWIGTYPE_p_switch_channel.getCPtr(channel), key, SWIGTYPE_p_void.getCPtr(private_info));
    return ret;
  }

  public static SWIGTYPE_p_void switch_channel_get_private(SWIGTYPE_p_switch_channel channel, string key) {
    IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_private(SWIGTYPE_p_switch_channel.getCPtr(channel), key);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_channel_set_name(SWIGTYPE_p_switch_channel channel, string name) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_set_name(SWIGTYPE_p_switch_channel.getCPtr(channel), name);
    return ret;
  }

  public static string switch_channel_get_name(SWIGTYPE_p_switch_channel channel) {
    string ret = freeswitchPINVOKE.switch_channel_get_name(SWIGTYPE_p_switch_channel.getCPtr(channel));
    return ret;
  }

  public static switch_channel_state_t switch_channel_perform_hangup(SWIGTYPE_p_switch_channel channel, string file, string func, int line, switch_call_cause_t hangup_cause) {
    switch_channel_state_t ret = (switch_channel_state_t)freeswitchPINVOKE.switch_channel_perform_hangup(SWIGTYPE_p_switch_channel.getCPtr(channel), file, func, line, (int)hangup_cause);
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_channel_has_dtmf(SWIGTYPE_p_switch_channel channel) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_channel_has_dtmf(SWIGTYPE_p_switch_channel.getCPtr(channel)), true);
    return ret;
  }

  public static switch_status_t switch_channel_queue_dtmf(SWIGTYPE_p_switch_channel channel, switch_dtmf_t dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_queue_dtmf(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_dtmf_t.getCPtr(dtmf));
    return ret;
  }

  public static switch_status_t switch_channel_queue_dtmf_string(SWIGTYPE_p_switch_channel channel, string dtmf_string) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_queue_dtmf_string(SWIGTYPE_p_switch_channel.getCPtr(channel), dtmf_string);
    return ret;
  }

  public static switch_status_t switch_channel_dequeue_dtmf(SWIGTYPE_p_switch_channel channel, switch_dtmf_t dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_dequeue_dtmf(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_dtmf_t.getCPtr(dtmf));
    return ret;
  }

  public static void switch_channel_flush_dtmf(SWIGTYPE_p_switch_channel channel) {
    freeswitchPINVOKE.switch_channel_flush_dtmf(SWIGTYPE_p_switch_channel.getCPtr(channel));
  }

  public static SWIGTYPE_p_switch_size_t switch_channel_dequeue_dtmf_string(SWIGTYPE_p_switch_channel channel, string dtmf_str, SWIGTYPE_p_switch_size_t len) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_channel_dequeue_dtmf_string(SWIGTYPE_p_switch_channel.getCPtr(channel), dtmf_str, SWIGTYPE_p_switch_size_t.getCPtr(len)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static string switch_channel_state_name(switch_channel_state_t state) {
    string ret = freeswitchPINVOKE.switch_channel_state_name((int)state);
    return ret;
  }

  public static switch_channel_state_t switch_channel_name_state(string name) {
    switch_channel_state_t ret = (switch_channel_state_t)freeswitchPINVOKE.switch_channel_name_state(name);
    return ret;
  }

  public static void switch_channel_event_set_data(SWIGTYPE_p_switch_channel channel, switch_event arg1) {
    freeswitchPINVOKE.switch_channel_event_set_data(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_event.getCPtr(arg1));
  }

  public static string switch_channel_expand_variables(SWIGTYPE_p_switch_channel channel, string arg1) {
    string ret = freeswitchPINVOKE.switch_channel_expand_variables(SWIGTYPE_p_switch_channel.getCPtr(channel), arg1);
    return ret;
  }

  public static string switch_channel_build_param_string(SWIGTYPE_p_switch_channel channel, switch_caller_profile caller_profile, string prefix) {
    string ret = freeswitchPINVOKE.switch_channel_build_param_string(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_profile.getCPtr(caller_profile), prefix);
    return ret;
  }

  public static switch_status_t switch_channel_set_timestamps(SWIGTYPE_p_switch_channel channel) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_set_timestamps(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();
    return ret;
  }

  public static switch_status_t switch_buffer_create_dynamic(SWIGTYPE_p_p_switch_buffer buffer, SWIGTYPE_p_switch_size_t blocksize, SWIGTYPE_p_switch_size_t start_len, SWIGTYPE_p_switch_size_t max_len) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_buffer_create_dynamic(SWIGTYPE_p_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_switch_size_t.getCPtr(blocksize), SWIGTYPE_p_switch_size_t.getCPtr(start_len), SWIGTYPE_p_switch_size_t.getCPtr(max_len));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void switch_buffer_add_mutex(SWIGTYPE_p_switch_buffer buffer, SWIGTYPE_p_switch_mutex_t mutex) {
    freeswitchPINVOKE.switch_buffer_add_mutex(SWIGTYPE_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_switch_mutex_t.getCPtr(mutex));
  }

  public static void switch_buffer_lock(SWIGTYPE_p_switch_buffer buffer) {
    freeswitchPINVOKE.switch_buffer_lock(SWIGTYPE_p_switch_buffer.getCPtr(buffer));
  }

  public static switch_status_t switch_buffer_trylock(SWIGTYPE_p_switch_buffer buffer) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_buffer_trylock(SWIGTYPE_p_switch_buffer.getCPtr(buffer));
    return ret;
  }

  public static void switch_buffer_unlock(SWIGTYPE_p_switch_buffer buffer) {
    freeswitchPINVOKE.switch_buffer_unlock(SWIGTYPE_p_switch_buffer.getCPtr(buffer));
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_len(SWIGTYPE_p_switch_buffer buffer) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_len(SWIGTYPE_p_switch_buffer.getCPtr(buffer)), true);
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_freespace(SWIGTYPE_p_switch_buffer buffer) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_freespace(SWIGTYPE_p_switch_buffer.getCPtr(buffer)), true);
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_inuse(SWIGTYPE_p_switch_buffer buffer) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_inuse(SWIGTYPE_p_switch_buffer.getCPtr(buffer)), true);
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_read(SWIGTYPE_p_switch_buffer buffer, SWIGTYPE_p_void data, SWIGTYPE_p_switch_size_t datalen) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_read(SWIGTYPE_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(datalen)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_read_loop(SWIGTYPE_p_switch_buffer buffer, SWIGTYPE_p_void data, SWIGTYPE_p_switch_size_t datalen) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_read_loop(SWIGTYPE_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(datalen)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void switch_buffer_set_loops(SWIGTYPE_p_switch_buffer buffer, int loops) {
    freeswitchPINVOKE.switch_buffer_set_loops(SWIGTYPE_p_switch_buffer.getCPtr(buffer), loops);
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_write(SWIGTYPE_p_switch_buffer buffer, SWIGTYPE_p_void data, SWIGTYPE_p_switch_size_t datalen) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_write(SWIGTYPE_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(datalen)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_toss(SWIGTYPE_p_switch_buffer buffer, SWIGTYPE_p_switch_size_t datalen) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_toss(SWIGTYPE_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_switch_size_t.getCPtr(datalen)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void switch_buffer_zero(SWIGTYPE_p_switch_buffer buffer) {
    freeswitchPINVOKE.switch_buffer_zero(SWIGTYPE_p_switch_buffer.getCPtr(buffer));
  }

  public static void switch_buffer_destroy(SWIGTYPE_p_p_switch_buffer buffer) {
    freeswitchPINVOKE.switch_buffer_destroy(SWIGTYPE_p_p_switch_buffer.getCPtr(buffer));
  }

  public static SWIGTYPE_p_switch_size_t switch_buffer_zwrite(SWIGTYPE_p_switch_buffer buffer, SWIGTYPE_p_void data, SWIGTYPE_p_switch_size_t datalen) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_buffer_zwrite(SWIGTYPE_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_switch_size_t.getCPtr(datalen)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_status_t switch_event_init(SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_event_shutdown() {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_shutdown();
    return ret;
  }

  public static switch_status_t switch_event_create_subclass(SWIGTYPE_p_p_switch_event arg0, switch_event_types_t event_id, string subclass_name) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_create_subclass(SWIGTYPE_p_p_switch_event.getCPtr(arg0), (int)event_id, subclass_name);
    return ret;
  }

  public static switch_status_t switch_event_set_priority(switch_event arg0, switch_priority_t priority) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_set_priority(switch_event.getCPtr(arg0), (int)priority);
    return ret;
  }

  public static string switch_event_get_header(switch_event arg0, string header_name) {
    string ret = freeswitchPINVOKE.switch_event_get_header(switch_event.getCPtr(arg0), header_name);
    return ret;
  }

  public static string switch_event_get_body(switch_event arg0) {
    string ret = freeswitchPINVOKE.switch_event_get_body(switch_event.getCPtr(arg0));
    return ret;
  }

  public static switch_status_t switch_event_add_header_string(switch_event arg0, switch_stack_t stack, string header_name, string data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_add_header_string(switch_event.getCPtr(arg0), (int)stack, header_name, data);
    return ret;
  }

  public static switch_status_t switch_event_del_header(switch_event arg0, string header_name) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_del_header(switch_event.getCPtr(arg0), header_name);
    return ret;
  }

  public static void switch_event_destroy(SWIGTYPE_p_p_switch_event arg0) {
    freeswitchPINVOKE.switch_event_destroy(SWIGTYPE_p_p_switch_event.getCPtr(arg0));
  }

  public static switch_status_t switch_event_dup(SWIGTYPE_p_p_switch_event arg0, switch_event todup) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_dup(SWIGTYPE_p_p_switch_event.getCPtr(arg0), switch_event.getCPtr(todup));
    return ret;
  }

  public static switch_status_t switch_event_fire_detailed(string file, string func, int line, SWIGTYPE_p_p_switch_event arg3, SWIGTYPE_p_void user_data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_fire_detailed(file, func, line, SWIGTYPE_p_p_switch_event.getCPtr(arg3), SWIGTYPE_p_void.getCPtr(user_data));
    return ret;
  }

  public static switch_status_t switch_event_bind(string id, switch_event_types_t arg1, string subclass_name, SWIGTYPE_p_f_p_switch_event__void callback, SWIGTYPE_p_void user_data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_bind(id, (int)arg1, subclass_name, SWIGTYPE_p_f_p_switch_event__void.getCPtr(callback), SWIGTYPE_p_void.getCPtr(user_data));
    return ret;
  }

  public static string switch_event_name(switch_event_types_t arg0) {
    string ret = freeswitchPINVOKE.switch_event_name((int)arg0);
    return ret;
  }

  public static switch_status_t switch_name_event(string name, SWIGTYPE_p_switch_event_types_t type) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_name_event(name, SWIGTYPE_p_switch_event_types_t.getCPtr(type));
    return ret;
  }

  public static switch_status_t switch_event_reserve_subclass_detailed(string owner, string subclass_name) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_reserve_subclass_detailed(owner, subclass_name);
    return ret;
  }

  public static switch_status_t switch_event_serialize(switch_event arg0, SWIGTYPE_p_p_char str, switch_bool_t encode) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_serialize(switch_event.getCPtr(arg0), SWIGTYPE_p_p_char.getCPtr(str), (int)encode);
    return ret;
  }

  public static switch_status_t switch_event_running() {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_running();
    return ret;
  }

  public static string switch_event_expand_headers(switch_event arg0, string arg1) {
    string ret = freeswitchPINVOKE.switch_event_expand_headers(switch_event.getCPtr(arg0), arg1);
    return ret;
  }

  public static switch_status_t switch_event_create_pres_in_detailed(string file, string func, int line, string proto, string login, string from, string from_domain, string status, string event_type, string alt_event_type, int event_count, string unique_id, string channel_state, string answer_state, string call_direction) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_event_create_pres_in_detailed(file, func, line, proto, login, from, from_domain, status, event_type, alt_event_type, event_count, unique_id, channel_state, answer_state, call_direction);
    return ret;
  }

  public static void switch_event_deliver(SWIGTYPE_p_p_switch_event arg0) {
    freeswitchPINVOKE.switch_event_deliver(SWIGTYPE_p_p_switch_event.getCPtr(arg0));
  }

  public static string switch_event_build_param_string(switch_event arg0, string prefix, SWIGTYPE_p_switch_hash vars_map) {
    string ret = freeswitchPINVOKE.switch_event_build_param_string(switch_event.getCPtr(arg0), prefix, SWIGTYPE_p_switch_hash.getCPtr(vars_map));
    return ret;
  }

  public static switch_status_t switch_resample_create(SWIGTYPE_p_p_switch_audio_resampler_t new_resampler, int from_rate, SWIGTYPE_p_switch_size_t from_size, int to_rate, uint to_size, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_resample_create(SWIGTYPE_p_p_switch_audio_resampler_t.getCPtr(new_resampler), from_rate, SWIGTYPE_p_switch_size_t.getCPtr(from_size), to_rate, to_size, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void switch_resample_destroy(SWIGTYPE_p_p_switch_audio_resampler_t resampler) {
    freeswitchPINVOKE.switch_resample_destroy(SWIGTYPE_p_p_switch_audio_resampler_t.getCPtr(resampler));
  }

  public static uint switch_resample_process(switch_audio_resampler_t resampler, SWIGTYPE_p_float src, int srclen, SWIGTYPE_p_float dst, uint dstlen, int last) {
    uint ret = freeswitchPINVOKE.switch_resample_process(switch_audio_resampler_t.getCPtr(resampler), SWIGTYPE_p_float.getCPtr(src), srclen, SWIGTYPE_p_float.getCPtr(dst), dstlen, last);
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_float_to_short(SWIGTYPE_p_float f, SWIGTYPE_p_short s, SWIGTYPE_p_switch_size_t len) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_float_to_short(SWIGTYPE_p_float.getCPtr(f), SWIGTYPE_p_short.getCPtr(s), SWIGTYPE_p_switch_size_t.getCPtr(len)), true);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static int switch_char_to_float(string c, SWIGTYPE_p_float f, int len) {
    int ret = freeswitchPINVOKE.switch_char_to_float(c, SWIGTYPE_p_float.getCPtr(f), len);
    return ret;
  }

  public static int switch_float_to_char(SWIGTYPE_p_float f, string c, int len) {
    int ret = freeswitchPINVOKE.switch_float_to_char(SWIGTYPE_p_float.getCPtr(f), c, len);
    return ret;
  }

  public static int switch_short_to_float(SWIGTYPE_p_short s, SWIGTYPE_p_float f, int len) {
    int ret = freeswitchPINVOKE.switch_short_to_float(SWIGTYPE_p_short.getCPtr(s), SWIGTYPE_p_float.getCPtr(f), len);
    return ret;
  }

  public static void switch_swap_linear(SWIGTYPE_p_short buf, int len) {
    freeswitchPINVOKE.switch_swap_linear(SWIGTYPE_p_short.getCPtr(buf), len);
  }

  public static void switch_generate_sln_silence(SWIGTYPE_p_short data, uint samples, uint divisor) {
    freeswitchPINVOKE.switch_generate_sln_silence(SWIGTYPE_p_short.getCPtr(data), samples, divisor);
  }

  public static void switch_change_sln_volume(SWIGTYPE_p_short data, uint samples, int vol) {
    freeswitchPINVOKE.switch_change_sln_volume(SWIGTYPE_p_short.getCPtr(data), samples, vol);
  }

  public static uint switch_merge_sln(SWIGTYPE_p_short data, uint samples, SWIGTYPE_p_short other_data, uint other_samples) {
    uint ret = freeswitchPINVOKE.switch_merge_sln(SWIGTYPE_p_short.getCPtr(data), samples, SWIGTYPE_p_short.getCPtr(other_data), other_samples);
    return ret;
  }

  public static switch_status_t switch_ivr_deactivate_unicast(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_deactivate_unicast(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_activate_unicast(SWIGTYPE_p_switch_core_session session, string local_ip, ushort local_port, string remote_ip, ushort remote_port, string transport, string flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_activate_unicast(SWIGTYPE_p_switch_core_session.getCPtr(session), local_ip, local_port, remote_ip, remote_port, transport, flags);
    return ret;
  }

  public static switch_status_t switch_ivr_generate_xml_cdr(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_xml xml_cdr) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_generate_xml_cdr(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_xml.getCPtr(xml_cdr));
    return ret;
  }

  public static int switch_ivr_set_xml_profile_data(switch_xml xml, switch_caller_profile caller_profile, int off) {
    int ret = freeswitchPINVOKE.switch_ivr_set_xml_profile_data(switch_xml.getCPtr(xml), switch_caller_profile.getCPtr(caller_profile), off);
    return ret;
  }

  public static int switch_ivr_set_xml_chan_vars(switch_xml xml, SWIGTYPE_p_switch_channel channel, int off) {
    int ret = freeswitchPINVOKE.switch_ivr_set_xml_chan_vars(switch_xml.getCPtr(xml), SWIGTYPE_p_switch_channel.getCPtr(channel), off);
    return ret;
  }

  public static switch_status_t switch_ivr_parse_event(SWIGTYPE_p_switch_core_session session, switch_event arg1) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_parse_event(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_event.getCPtr(arg1));
    return ret;
  }

  public static switch_status_t switch_ivr_parse_all_events(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_parse_all_events(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_parse_next_event(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_parse_next_event(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_sleep(SWIGTYPE_p_switch_core_session session, uint ms) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_sleep(SWIGTYPE_p_switch_core_session.getCPtr(session), ms);
    return ret;
  }

  public static switch_status_t switch_ivr_park(SWIGTYPE_p_switch_core_session session, switch_input_args_t args) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_park(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_input_args_t.getCPtr(args));
    return ret;
  }

  public static switch_status_t switch_ivr_collect_digits_callback(SWIGTYPE_p_switch_core_session session, switch_input_args_t args, uint timeout) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_collect_digits_callback(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_input_args_t.getCPtr(args), timeout);
    return ret;
  }

  public static switch_status_t switch_ivr_collect_digits_count(SWIGTYPE_p_switch_core_session session, string buf, SWIGTYPE_p_switch_size_t buflen, SWIGTYPE_p_switch_size_t maxdigits, string terminators, string terminator, uint first_timeout, uint digit_timeout, uint abs_timeout) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_collect_digits_count(SWIGTYPE_p_switch_core_session.getCPtr(session), buf, SWIGTYPE_p_switch_size_t.getCPtr(buflen), SWIGTYPE_p_switch_size_t.getCPtr(maxdigits), terminators, terminator, first_timeout, digit_timeout, abs_timeout);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_status_t switch_ivr_detect_speech(SWIGTYPE_p_switch_core_session session, string mod_name, string grammar, string path, string dest, switch_asr_handle ah) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_detect_speech(SWIGTYPE_p_switch_core_session.getCPtr(session), mod_name, grammar, path, dest, switch_asr_handle.getCPtr(ah));
    return ret;
  }

  public static switch_status_t switch_ivr_stop_detect_speech(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_stop_detect_speech(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_pause_detect_speech(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_pause_detect_speech(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_resume_detect_speech(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_resume_detect_speech(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_detect_speech_load_grammar(SWIGTYPE_p_switch_core_session session, string grammar, string path) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_detect_speech_load_grammar(SWIGTYPE_p_switch_core_session.getCPtr(session), grammar, path);
    return ret;
  }

  public static switch_status_t switch_ivr_detect_speech_unload_grammar(SWIGTYPE_p_switch_core_session session, string grammar) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_detect_speech_unload_grammar(SWIGTYPE_p_switch_core_session.getCPtr(session), grammar);
    return ret;
  }

  public static switch_status_t switch_ivr_record_session(SWIGTYPE_p_switch_core_session session, string file, uint limit, switch_file_handle fh) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_record_session(SWIGTYPE_p_switch_core_session.getCPtr(session), file, limit, switch_file_handle.getCPtr(fh));
    return ret;
  }

  public static switch_status_t switch_ivr_eavesdrop_session(SWIGTYPE_p_switch_core_session session, string uuid, string require_group, uint flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_eavesdrop_session(SWIGTYPE_p_switch_core_session.getCPtr(session), uuid, require_group, flags);
    return ret;
  }

  public static switch_status_t switch_ivr_displace_session(SWIGTYPE_p_switch_core_session session, string file, uint limit, string flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_displace_session(SWIGTYPE_p_switch_core_session.getCPtr(session), file, limit, flags);
    return ret;
  }

  public static switch_status_t switch_ivr_stop_displace_session(SWIGTYPE_p_switch_core_session session, string file) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_stop_displace_session(SWIGTYPE_p_switch_core_session.getCPtr(session), file);
    return ret;
  }

  public static switch_status_t switch_ivr_stop_record_session(SWIGTYPE_p_switch_core_session session, string file) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_stop_record_session(SWIGTYPE_p_switch_core_session.getCPtr(session), file);
    return ret;
  }

  public static switch_status_t switch_ivr_inband_dtmf_session(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_inband_dtmf_session(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_stop_inband_dtmf_session(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_stop_inband_dtmf_session(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_inband_dtmf_generate_session(SWIGTYPE_p_switch_core_session session, switch_bool_t read_stream) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_inband_dtmf_generate_session(SWIGTYPE_p_switch_core_session.getCPtr(session), (int)read_stream);
    return ret;
  }

  public static switch_status_t switch_ivr_stop_inband_dtmf_generate_session(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_stop_inband_dtmf_generate_session(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static void switch_ivr_session_echo(SWIGTYPE_p_switch_core_session session) {
    freeswitchPINVOKE.switch_ivr_session_echo(SWIGTYPE_p_switch_core_session.getCPtr(session));
  }

  public static switch_status_t switch_ivr_stop_tone_detect_session(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_stop_tone_detect_session(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_tone_detect_session(SWIGTYPE_p_switch_core_session session, string key, string tone_spec, string flags, SWIGTYPE_p_time_t timeout, string app, string data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_tone_detect_session(SWIGTYPE_p_switch_core_session.getCPtr(session), key, tone_spec, flags, SWIGTYPE_p_time_t.getCPtr(timeout), app, data);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_status_t switch_ivr_play_file(SWIGTYPE_p_switch_core_session session, switch_file_handle fh, string file, switch_input_args_t args) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_play_file(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_file_handle.getCPtr(fh), file, switch_input_args_t.getCPtr(args));
    return ret;
  }

  public static switch_status_t switch_ivr_gentones(SWIGTYPE_p_switch_core_session session, string script, int loops, switch_input_args_t args) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_gentones(SWIGTYPE_p_switch_core_session.getCPtr(session), script, loops, switch_input_args_t.getCPtr(args));
    return ret;
  }

  public static switch_status_t switch_ivr_record_file(SWIGTYPE_p_switch_core_session session, switch_file_handle fh, string file, switch_input_args_t args, uint limit) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_record_file(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_file_handle.getCPtr(fh), file, switch_input_args_t.getCPtr(args), limit);
    return ret;
  }

  public static switch_status_t switch_play_and_get_digits(SWIGTYPE_p_switch_core_session session, uint min_digits, uint max_digits, uint max_tries, uint timeout, string valid_terminators, string audio_file, string bad_input_audio_file, SWIGTYPE_p_void digit_buffer, uint digit_buffer_length, string digits_regex) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_play_and_get_digits(SWIGTYPE_p_switch_core_session.getCPtr(session), min_digits, max_digits, max_tries, timeout, valid_terminators, audio_file, bad_input_audio_file, SWIGTYPE_p_void.getCPtr(digit_buffer), digit_buffer_length, digits_regex);
    return ret;
  }

  public static switch_status_t switch_ivr_speak_text_handle(SWIGTYPE_p_switch_core_session session, switch_speech_handle sh, switch_codec codec, switch_timer timer, string text, switch_input_args_t args) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_speak_text_handle(SWIGTYPE_p_switch_core_session.getCPtr(session), switch_speech_handle.getCPtr(sh), switch_codec.getCPtr(codec), switch_timer.getCPtr(timer), text, switch_input_args_t.getCPtr(args));
    return ret;
  }

  public static void switch_ivr_clear_speech_cache(SWIGTYPE_p_switch_core_session session) {
    freeswitchPINVOKE.switch_ivr_clear_speech_cache(SWIGTYPE_p_switch_core_session.getCPtr(session));
  }

  public static switch_status_t switch_ivr_speak_text(SWIGTYPE_p_switch_core_session session, string tts_name, string voice_name, string text, switch_input_args_t args) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_speak_text(SWIGTYPE_p_switch_core_session.getCPtr(session), tts_name, voice_name, text, switch_input_args_t.getCPtr(args));
    return ret;
  }

  public static switch_status_t switch_ivr_originate(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_core_session bleg, SWIGTYPE_p_switch_call_cause_t cause, string bridgeto, uint timelimit_sec, switch_state_handler_table table, string cid_name_override, string cid_num_override, switch_caller_profile caller_profile_override, uint flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_originate(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_core_session.getCPtr(bleg), SWIGTYPE_p_switch_call_cause_t.getCPtr(cause), bridgeto, timelimit_sec, switch_state_handler_table.getCPtr(table), cid_name_override, cid_num_override, switch_caller_profile.getCPtr(caller_profile_override), flags);
    return ret;
  }

  public static switch_status_t switch_ivr_multi_threaded_bridge(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_switch_core_session peer_session, SWIGTYPE_p_f_p_switch_core_session_p_void_enum_switch_input_type_t_p_void_unsigned_int__switch_status_t dtmf_callback, SWIGTYPE_p_void session_data, SWIGTYPE_p_void peer_session_data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_multi_threaded_bridge(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_switch_core_session.getCPtr(peer_session), SWIGTYPE_p_f_p_switch_core_session_p_void_enum_switch_input_type_t_p_void_unsigned_int__switch_status_t.getCPtr(dtmf_callback), SWIGTYPE_p_void.getCPtr(session_data), SWIGTYPE_p_void.getCPtr(peer_session_data));
    return ret;
  }

  public static switch_status_t switch_ivr_signal_bridge(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_switch_core_session peer_session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_signal_bridge(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_switch_core_session.getCPtr(peer_session));
    return ret;
  }

  public static switch_status_t switch_ivr_session_transfer(SWIGTYPE_p_switch_core_session session, string extension, string dialplan, string context) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_session_transfer(SWIGTYPE_p_switch_core_session.getCPtr(session), extension, dialplan, context);
    return ret;
  }

  public static uint switch_ivr_schedule_transfer(SWIGTYPE_p_time_t runtime, string uuid, string extension, string dialplan, string context) {
    uint ret = freeswitchPINVOKE.switch_ivr_schedule_transfer(SWIGTYPE_p_time_t.getCPtr(runtime), uuid, extension, dialplan, context);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static uint switch_ivr_schedule_hangup(SWIGTYPE_p_time_t runtime, string uuid, switch_call_cause_t cause, switch_bool_t bleg) {
    uint ret = freeswitchPINVOKE.switch_ivr_schedule_hangup(SWIGTYPE_p_time_t.getCPtr(runtime), uuid, (int)cause, (int)bleg);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_status_t switch_ivr_uuid_bridge(string originator_uuid, string originatee_uuid) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_uuid_bridge(originator_uuid, originatee_uuid);
    return ret;
  }

  public static switch_status_t switch_ivr_media(string uuid, uint flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_media(uuid, flags);
    return ret;
  }

  public static switch_status_t switch_ivr_nomedia(string uuid, uint flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_nomedia(uuid, flags);
    return ret;
  }

  public static switch_status_t switch_ivr_hold_uuid(string uuid, string message, switch_bool_t moh) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_hold_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;
  }

  public static switch_status_t switch_ivr_hold(SWIGTYPE_p_switch_core_session session, string message, switch_bool_t moh) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_hold(SWIGTYPE_p_switch_core_session.getCPtr(session), message, (int)moh);
    return ret;
  }

  public static switch_status_t switch_ivr_unhold(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_unhold(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static uint switch_ivr_schedule_broadcast(SWIGTYPE_p_time_t runtime, string uuid, string path, uint flags) {
    uint ret = freeswitchPINVOKE.switch_ivr_schedule_broadcast(SWIGTYPE_p_time_t.getCPtr(runtime), uuid, path, flags);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_status_t switch_ivr_broadcast(string uuid, string path, uint flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_broadcast(uuid, path, flags);
    return ret;
  }

  public static switch_status_t switch_ivr_transfer_variable(SWIGTYPE_p_switch_core_session sessa, SWIGTYPE_p_switch_core_session sessb, string var) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_transfer_variable(SWIGTYPE_p_switch_core_session.getCPtr(sessa), SWIGTYPE_p_switch_core_session.getCPtr(sessb), var);
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_parser_new(SWIGTYPE_p_apr_pool_t pool, SWIGTYPE_p_p_switch_ivr_digit_stream_parser parser) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_parser_new(SWIGTYPE_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_p_switch_ivr_digit_stream_parser.getCPtr(parser));
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_parser_destroy(SWIGTYPE_p_switch_ivr_digit_stream_parser parser) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_parser_destroy(SWIGTYPE_p_switch_ivr_digit_stream_parser.getCPtr(parser));
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_new(SWIGTYPE_p_switch_ivr_digit_stream_parser parser, SWIGTYPE_p_p_switch_ivr_digit_stream stream) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_new(SWIGTYPE_p_switch_ivr_digit_stream_parser.getCPtr(parser), SWIGTYPE_p_p_switch_ivr_digit_stream.getCPtr(stream));
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_destroy(SWIGTYPE_p_switch_ivr_digit_stream stream) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_destroy(SWIGTYPE_p_switch_ivr_digit_stream.getCPtr(stream));
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_parser_set_event(SWIGTYPE_p_switch_ivr_digit_stream_parser parser, string digits, SWIGTYPE_p_void data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_parser_set_event(SWIGTYPE_p_switch_ivr_digit_stream_parser.getCPtr(parser), digits, SWIGTYPE_p_void.getCPtr(data));
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_parser_del_event(SWIGTYPE_p_switch_ivr_digit_stream_parser parser, string digits) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_parser_del_event(SWIGTYPE_p_switch_ivr_digit_stream_parser.getCPtr(parser), digits);
    return ret;
  }

  public static SWIGTYPE_p_void switch_ivr_digit_stream_parser_feed(SWIGTYPE_p_switch_ivr_digit_stream_parser parser, SWIGTYPE_p_switch_ivr_digit_stream stream, char digit) {
    IntPtr cPtr = freeswitchPINVOKE.switch_ivr_digit_stream_parser_feed(SWIGTYPE_p_switch_ivr_digit_stream_parser.getCPtr(parser), SWIGTYPE_p_switch_ivr_digit_stream.getCPtr(stream), digit);
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_reset(SWIGTYPE_p_switch_ivr_digit_stream stream) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_reset(SWIGTYPE_p_switch_ivr_digit_stream.getCPtr(stream));
    return ret;
  }

  public static switch_status_t switch_ivr_digit_stream_parser_set_terminator(SWIGTYPE_p_switch_ivr_digit_stream_parser parser, char digit) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_digit_stream_parser_set_terminator(SWIGTYPE_p_switch_ivr_digit_stream_parser.getCPtr(parser), digit);
    return ret;
  }

  public static switch_status_t switch_ivr_menu_init(SWIGTYPE_p_p_switch_ivr_menu new_menu, SWIGTYPE_p_switch_ivr_menu main, string name, string greeting_sound, string short_greeting_sound, string invalid_sound, string exit_sound, string confirm_macro, string confirm_key, int confirm_attempts, int inter_timeout, int digit_len, int timeout, int max_failures, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_init(SWIGTYPE_p_p_switch_ivr_menu.getCPtr(new_menu), SWIGTYPE_p_switch_ivr_menu.getCPtr(main), name, greeting_sound, short_greeting_sound, invalid_sound, exit_sound, confirm_macro, confirm_key, confirm_attempts, inter_timeout, digit_len, timeout, max_failures, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_ivr_menu_bind_action(SWIGTYPE_p_switch_ivr_menu menu, switch_ivr_action_t ivr_action, string arg, string bind) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_bind_action(SWIGTYPE_p_switch_ivr_menu.getCPtr(menu), (int)ivr_action, arg, bind);
    return ret;
  }

  public static switch_status_t switch_ivr_menu_bind_function(SWIGTYPE_p_switch_ivr_menu menu, SWIGTYPE_p_switch_ivr_menu_action_function_t function, string arg, string bind) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_bind_function(SWIGTYPE_p_switch_ivr_menu.getCPtr(menu), SWIGTYPE_p_switch_ivr_menu_action_function_t.getCPtr(function), arg, bind);
    return ret;
  }

  public static switch_status_t switch_ivr_menu_execute(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_switch_ivr_menu stack, string name, SWIGTYPE_p_void obj) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_execute(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_switch_ivr_menu.getCPtr(stack), name, SWIGTYPE_p_void.getCPtr(obj));
    return ret;
  }

  public static switch_status_t switch_ivr_menu_stack_free(SWIGTYPE_p_switch_ivr_menu stack) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_stack_free(SWIGTYPE_p_switch_ivr_menu.getCPtr(stack));
    return ret;
  }

  public static switch_status_t switch_ivr_menu_stack_xml_build(SWIGTYPE_p_switch_ivr_menu_xml_ctx xml_menu_ctx, SWIGTYPE_p_p_switch_ivr_menu menu_stack, switch_xml xml_menus, switch_xml xml_menu) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_stack_xml_build(SWIGTYPE_p_switch_ivr_menu_xml_ctx.getCPtr(xml_menu_ctx), SWIGTYPE_p_p_switch_ivr_menu.getCPtr(menu_stack), switch_xml.getCPtr(xml_menus), switch_xml.getCPtr(xml_menu));
    return ret;
  }

  public static switch_status_t switch_ivr_menu_str2action(string action_name, SWIGTYPE_p_switch_ivr_action_t action) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_str2action(action_name, SWIGTYPE_p_switch_ivr_action_t.getCPtr(action));
    return ret;
  }

  public static switch_status_t switch_ivr_menu_stack_xml_add_custom(SWIGTYPE_p_switch_ivr_menu_xml_ctx xml_menu_ctx, string name, SWIGTYPE_p_switch_ivr_menu_action_function_t function) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_stack_xml_add_custom(SWIGTYPE_p_switch_ivr_menu_xml_ctx.getCPtr(xml_menu_ctx), name, SWIGTYPE_p_switch_ivr_menu_action_function_t.getCPtr(function));
    return ret;
  }

  public static switch_status_t switch_ivr_menu_stack_xml_init(SWIGTYPE_p_p_switch_ivr_menu_xml_ctx xml_menu_ctx, SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_menu_stack_xml_init(SWIGTYPE_p_p_switch_ivr_menu_xml_ctx.getCPtr(xml_menu_ctx), SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_ivr_phrase_macro(SWIGTYPE_p_switch_core_session session, string macro_name, string data, string lang, switch_input_args_t args) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_phrase_macro(SWIGTYPE_p_switch_core_session.getCPtr(session), macro_name, data, lang, switch_input_args_t.getCPtr(args));
    return ret;
  }

  public static void switch_ivr_delay_echo(SWIGTYPE_p_switch_core_session session, uint delay_ms) {
    freeswitchPINVOKE.switch_ivr_delay_echo(SWIGTYPE_p_switch_core_session.getCPtr(session), delay_ms);
  }

  public static switch_status_t switch_ivr_find_bridged_uuid(string uuid, string b_uuid, SWIGTYPE_p_switch_size_t blen) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_find_bridged_uuid(uuid, b_uuid, SWIGTYPE_p_switch_size_t.getCPtr(blen));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static void switch_ivr_intercept_session(SWIGTYPE_p_switch_core_session session, string uuid, switch_bool_t bleg) {
    freeswitchPINVOKE.switch_ivr_intercept_session(SWIGTYPE_p_switch_core_session.getCPtr(session), uuid, (int)bleg);
  }

  public static void switch_ivr_park_session(SWIGTYPE_p_switch_core_session session) {
    freeswitchPINVOKE.switch_ivr_park_session(SWIGTYPE_p_switch_core_session.getCPtr(session));
  }

  public static switch_status_t switch_ivr_wait_for_answer(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_switch_core_session peer_session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_wait_for_answer(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_switch_core_session.getCPtr(peer_session));
    return ret;
  }

  public static switch_status_t switch_ivr_read(SWIGTYPE_p_switch_core_session session, uint min_digits, uint max_digits, string prompt_audio_file, string var_name, string digit_buffer, SWIGTYPE_p_switch_size_t digit_buffer_length, uint timeout, string valid_terminators) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_read(SWIGTYPE_p_switch_core_session.getCPtr(session), min_digits, max_digits, prompt_audio_file, var_name, digit_buffer, SWIGTYPE_p_switch_size_t.getCPtr(digit_buffer_length), timeout, valid_terminators);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_status_t switch_ivr_bind_dtmf_meta_session(SWIGTYPE_p_switch_core_session session, uint key, uint bind_flags, string app) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_bind_dtmf_meta_session(SWIGTYPE_p_switch_core_session.getCPtr(session), key, bind_flags, app);
    return ret;
  }

  public static switch_status_t switch_ivr_unbind_dtmf_meta_session(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_unbind_dtmf_meta_session(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t switch_ivr_soft_hold(SWIGTYPE_p_switch_core_session session, string unhold_key, string moh_a, string moh_b) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_soft_hold(SWIGTYPE_p_switch_core_session.getCPtr(session), unhold_key, moh_a, moh_b);
    return ret;
  }

  public static switch_status_t switch_ivr_say(SWIGTYPE_p_switch_core_session session, string tosay, string module_name, string say_type, string say_method, switch_input_args_t args) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_say(SWIGTYPE_p_switch_core_session.getCPtr(session), tosay, module_name, say_type, say_method, switch_input_args_t.getCPtr(args));
    return ret;
  }

  public static switch_say_method_t switch_ivr_get_say_method_by_name(string name) {
    switch_say_method_t ret = (switch_say_method_t)freeswitchPINVOKE.switch_ivr_get_say_method_by_name(name);
    return ret;
  }

  public static switch_say_type_t switch_ivr_get_say_type_by_name(string name) {
    switch_say_type_t ret = (switch_say_type_t)freeswitchPINVOKE.switch_ivr_get_say_type_by_name(name);
    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();
    return ret;
  }

  public static void switch_rtp_get_random(SWIGTYPE_p_void buf, uint len) {
    freeswitchPINVOKE.switch_rtp_get_random(SWIGTYPE_p_void.getCPtr(buf), len);
  }

  public static void switch_rtp_init(SWIGTYPE_p_apr_pool_t pool) {
    freeswitchPINVOKE.switch_rtp_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool));
  }

  public static void switch_rtp_shutdown() {
    freeswitchPINVOKE.switch_rtp_shutdown();
  }

  public static ushort switch_rtp_set_start_port(ushort port) {
    ushort ret = freeswitchPINVOKE.switch_rtp_set_start_port(port);
    return ret;
  }

  public static ushort switch_rtp_set_end_port(ushort port) {
    ushort ret = freeswitchPINVOKE.switch_rtp_set_end_port(port);
    return ret;
  }

  public static ushort switch_rtp_request_port(string ip) {
    ushort ret = freeswitchPINVOKE.switch_rtp_request_port(ip);
    return ret;
  }

  public static void switch_rtp_release_port(string ip, ushort port) {
    freeswitchPINVOKE.switch_rtp_release_port(ip, port);
  }

  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, SWIGTYPE_p_p_char 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, SWIGTYPE_p_p_char.getCPtr(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, SWIGTYPE_p_p_char 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, SWIGTYPE_p_p_char.getCPtr(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;
  }

  public static switch_status_t switch_rtp_set_remote_address(SWIGTYPE_p_switch_rtp rtp_session, string host, ushort port, SWIGTYPE_p_p_char err) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_set_remote_address(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), host, port, SWIGTYPE_p_p_char.getCPtr(err));
    return ret;
  }

  public static void switch_rtp_set_max_missed_packets(SWIGTYPE_p_switch_rtp rtp_session, uint max) {
    freeswitchPINVOKE.switch_rtp_set_max_missed_packets(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), max);
  }

  public static switch_status_t switch_rtp_set_local_address(SWIGTYPE_p_switch_rtp rtp_session, string host, ushort port, SWIGTYPE_p_p_char err) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_set_local_address(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), host, port, SWIGTYPE_p_p_char.getCPtr(err));
    return ret;
  }

  public static void switch_rtp_kill_socket(SWIGTYPE_p_switch_rtp rtp_session) {
    freeswitchPINVOKE.switch_rtp_kill_socket(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
  }

  public static void switch_rtp_break(SWIGTYPE_p_switch_rtp rtp_session) {
    freeswitchPINVOKE.switch_rtp_break(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
  }

  public static byte switch_rtp_ready(SWIGTYPE_p_switch_rtp rtp_session) {
    byte ret = freeswitchPINVOKE.switch_rtp_ready(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
    return ret;
  }

  public static void switch_rtp_destroy(SWIGTYPE_p_p_switch_rtp rtp_session) {
    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) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), login, rlogin);
    return ret;
  }

  public static switch_status_t switch_rtp_activate_jitter_buffer(SWIGTYPE_p_switch_rtp rtp_session, uint queue_frames) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_jitter_buffer(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), queue_frames);
    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 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);
    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 SWIGTYPE_p_switch_socket_t switch_rtp_get_rtp_socket(SWIGTYPE_p_switch_rtp rtp_session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_rtp_get_rtp_socket(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
    SWIGTYPE_p_switch_socket_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_socket_t(cPtr, false);
    return ret;
  }

  public static void switch_rtp_set_default_samples_per_interval(SWIGTYPE_p_switch_rtp rtp_session, ushort samples_per_interval) {
    freeswitchPINVOKE.switch_rtp_set_default_samples_per_interval(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), samples_per_interval);
  }

  public static uint switch_rtp_get_default_samples_per_interval(SWIGTYPE_p_switch_rtp rtp_session) {
    uint ret = freeswitchPINVOKE.switch_rtp_get_default_samples_per_interval(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
    return ret;
  }

  public static void switch_rtp_set_default_payload(SWIGTYPE_p_switch_rtp rtp_session, byte payload) {
    freeswitchPINVOKE.switch_rtp_set_default_payload(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), payload);
  }

  public static uint switch_rtp_get_default_payload(SWIGTYPE_p_switch_rtp rtp_session) {
    uint ret = freeswitchPINVOKE.switch_rtp_get_default_payload(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
    return ret;
  }

  public static void switch_rtp_set_invald_handler(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_f_p_switch_rtp_p_switch_socket_t_p_void_switch_size_t_p_switch_sockaddr_t__void on_invalid) {
    freeswitchPINVOKE.switch_rtp_set_invald_handler(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_f_p_switch_rtp_p_switch_socket_t_p_void_switch_size_t_p_switch_sockaddr_t__void.getCPtr(on_invalid));
  }

  public static switch_status_t switch_rtp_read(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_void data, SWIGTYPE_p_unsigned_long datalen, SWIGTYPE_p_unsigned_char payload_type, SWIGTYPE_p_unsigned_long flags, uint io_flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_read(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_unsigned_long.getCPtr(datalen), SWIGTYPE_p_unsigned_char.getCPtr(payload_type), SWIGTYPE_p_unsigned_long.getCPtr(flags), io_flags);
    return ret;
  }

  public static switch_status_t switch_rtp_queue_rfc2833(SWIGTYPE_p_switch_rtp rtp_session, switch_dtmf_t dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_queue_rfc2833(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), switch_dtmf_t.getCPtr(dtmf));
    return ret;
  }

  public static switch_status_t switch_rtp_queue_rfc2833_in(SWIGTYPE_p_switch_rtp rtp_session, switch_dtmf_t dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_queue_rfc2833_in(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), switch_dtmf_t.getCPtr(dtmf));
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_rtp_has_dtmf(SWIGTYPE_p_switch_rtp rtp_session) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_rtp_has_dtmf(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session)), true);
    return ret;
  }

  public static SWIGTYPE_p_switch_size_t switch_rtp_dequeue_dtmf(SWIGTYPE_p_switch_rtp rtp_session, switch_dtmf_t dtmf) {
    SWIGTYPE_p_switch_size_t ret = new SWIGTYPE_p_switch_size_t(freeswitchPINVOKE.switch_rtp_dequeue_dtmf(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), switch_dtmf_t.getCPtr(dtmf)), true);
    return ret;
  }

  public static switch_status_t switch_rtp_zerocopy_read(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_p_void data, SWIGTYPE_p_unsigned_long datalen, SWIGTYPE_p_unsigned_char payload_type, SWIGTYPE_p_unsigned_long flags, uint io_flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_zerocopy_read(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_p_void.getCPtr(data), SWIGTYPE_p_unsigned_long.getCPtr(datalen), SWIGTYPE_p_unsigned_char.getCPtr(payload_type), SWIGTYPE_p_unsigned_long.getCPtr(flags), io_flags);
    return ret;
  }

  public static switch_status_t switch_rtp_zerocopy_read_frame(SWIGTYPE_p_switch_rtp rtp_session, switch_frame frame, uint io_flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_zerocopy_read_frame(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), switch_frame.getCPtr(frame), io_flags);
    return ret;
  }

  public static switch_status_t switch_rtp_enable_vad(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_switch_core_session session, switch_codec codec, uint flags) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_enable_vad(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_switch_core_session.getCPtr(session), switch_codec.getCPtr(codec), flags);
    return ret;
  }

  public static switch_status_t switch_rtp_disable_vad(SWIGTYPE_p_switch_rtp rtp_session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_disable_vad(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
    return ret;
  }

  public static int switch_rtp_write_frame(SWIGTYPE_p_switch_rtp rtp_session, switch_frame frame) {
    int ret = freeswitchPINVOKE.switch_rtp_write_frame(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), switch_frame.getCPtr(frame));
    return ret;
  }

  public static int switch_rtp_write_manual(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_void data, uint datalen, byte m, byte payload, uint ts, SWIGTYPE_p_unsigned_long flags) {
    int ret = freeswitchPINVOKE.switch_rtp_write_manual(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_void.getCPtr(data), datalen, m, payload, ts, SWIGTYPE_p_unsigned_long.getCPtr(flags));
    return ret;
  }

  public static uint switch_rtp_get_ssrc(SWIGTYPE_p_switch_rtp rtp_session) {
    uint ret = freeswitchPINVOKE.switch_rtp_get_ssrc(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
    return ret;
  }

  public static void switch_rtp_set_private(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_void private_data) {
    freeswitchPINVOKE.switch_rtp_set_private(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_void.getCPtr(private_data));
  }

  public static void switch_rtp_set_telephony_event(SWIGTYPE_p_switch_rtp rtp_session, byte te) {
    freeswitchPINVOKE.switch_rtp_set_telephony_event(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), te);
  }

  public static void switch_rtp_set_cng_pt(SWIGTYPE_p_switch_rtp rtp_session, byte pt) {
    freeswitchPINVOKE.switch_rtp_set_cng_pt(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), pt);
  }

  public static SWIGTYPE_p_void switch_rtp_get_private(SWIGTYPE_p_switch_rtp rtp_session) {
    IntPtr cPtr = freeswitchPINVOKE.switch_rtp_get_private(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_log_init(SWIGTYPE_p_apr_pool_t pool) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_log_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool));
    return ret;
  }

  public static switch_status_t switch_log_shutdown() {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_log_shutdown();
    return ret;
  }

  public static switch_status_t switch_log_bind_logger(SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t function, switch_log_level_t level) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_log_bind_logger(SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t.getCPtr(function), (int)level);
    return ret;
  }

  public static string switch_log_level2str(switch_log_level_t level) {
    string ret = freeswitchPINVOKE.switch_log_level2str((int)level);
    return ret;
  }

  public static switch_log_level_t switch_log_str2level(string str) {
    switch_log_level_t ret = (switch_log_level_t)freeswitchPINVOKE.switch_log_str2level(str);
    return ret;
  }

  public static uint switch_log_str2mask(string str) {
    uint ret = freeswitchPINVOKE.switch_log_str2mask(str);
    return ret;
  }

  public static switch_xml switch_xml_parse_str(string s, SWIGTYPE_p_switch_size_t len) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_parse_str(s, SWIGTYPE_p_switch_size_t.getCPtr(len));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_xml switch_xml_parse_fd(int fd) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_parse_fd(fd);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_parse_file(string file) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_parse_file(file);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_parse_file_simple(string file) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_parse_file_simple(file);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_parse_fp(SWIGTYPE_p_FILE fp) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_parse_fp(SWIGTYPE_p_FILE.getCPtr(fp));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_child(switch_xml xml, string name) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_child(switch_xml.getCPtr(xml), name);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_find_child(switch_xml node, string childname, string attrname, string value) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_find_child(switch_xml.getCPtr(node), childname, attrname, value);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static string switch_xml_attr(switch_xml xml, string attr) {
    string ret = freeswitchPINVOKE.switch_xml_attr(switch_xml.getCPtr(xml), attr);
    return ret;
  }

  public static string switch_xml_attr_soft(switch_xml xml, string attr) {
    string ret = freeswitchPINVOKE.switch_xml_attr_soft(switch_xml.getCPtr(xml), attr);
    return ret;
  }

  public static switch_xml switch_xml_get(switch_xml xml) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_get(switch_xml.getCPtr(xml));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static string switch_xml_toxml(switch_xml xml, switch_bool_t prn_header) {
    string ret = freeswitchPINVOKE.switch_xml_toxml(switch_xml.getCPtr(xml), (int)prn_header);
    return ret;
  }

  public static string switch_xml_toxml_buf(switch_xml xml, string buf, SWIGTYPE_p_switch_size_t buflen, SWIGTYPE_p_switch_size_t offset, switch_bool_t prn_header) {
    string ret = freeswitchPINVOKE.switch_xml_toxml_buf(switch_xml.getCPtr(xml), buf, SWIGTYPE_p_switch_size_t.getCPtr(buflen), SWIGTYPE_p_switch_size_t.getCPtr(offset), (int)prn_header);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static SWIGTYPE_p_p_char switch_xml_pi(switch_xml xml, string target) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_pi(switch_xml.getCPtr(xml), target);
    SWIGTYPE_p_p_char ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_char(cPtr, false);
    return ret;
  }

  public static void switch_xml_free(switch_xml xml) {
    freeswitchPINVOKE.switch_xml_free(switch_xml.getCPtr(xml));
  }

  public static string switch_xml_error(switch_xml xml) {
    string ret = freeswitchPINVOKE.switch_xml_error(switch_xml.getCPtr(xml));
    return ret;
  }

  public static switch_xml switch_xml_new(string name) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_new(name);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_add_child(switch_xml xml, string name, SWIGTYPE_p_switch_size_t off) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_add_child(switch_xml.getCPtr(xml), name, SWIGTYPE_p_switch_size_t.getCPtr(off));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_xml switch_xml_set_txt(switch_xml xml, string txt) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_set_txt(switch_xml.getCPtr(xml), txt);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_set_attr(switch_xml xml, string name, string value) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_set_attr(switch_xml.getCPtr(xml), name, value);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_set_flag(switch_xml xml, switch_xml_flag_t flag) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_set_flag(switch_xml.getCPtr(xml), (int)flag);
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_cut(switch_xml xml) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_cut(switch_xml.getCPtr(xml));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_xml switch_xml_insert(switch_xml xml, switch_xml dest, SWIGTYPE_p_switch_size_t off) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_insert(switch_xml.getCPtr(xml), switch_xml.getCPtr(dest), SWIGTYPE_p_switch_size_t.getCPtr(off));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static switch_xml switch_xml_open_root(byte reload, SWIGTYPE_p_p_char err) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_open_root(reload, SWIGTYPE_p_p_char.getCPtr(err));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_xml_init(SWIGTYPE_p_apr_pool_t pool, SWIGTYPE_p_p_char err) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_xml_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_p_char.getCPtr(err));
    return ret;
  }

  public static switch_status_t switch_xml_destroy() {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_xml_destroy();
    return ret;
  }

  public static switch_xml switch_xml_root() {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_root();
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_xml_locate(string section, string tag_name, string key_name, string key_value, SWIGTYPE_p_p_switch_xml root, SWIGTYPE_p_p_switch_xml node, switch_event arg6) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_xml_locate(section, tag_name, key_name, key_value, SWIGTYPE_p_p_switch_xml.getCPtr(root), SWIGTYPE_p_p_switch_xml.getCPtr(node), switch_event.getCPtr(arg6));
    return ret;
  }

  public static switch_status_t switch_xml_locate_domain(string domain_name, switch_event arg1, SWIGTYPE_p_p_switch_xml root, SWIGTYPE_p_p_switch_xml domain) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_xml_locate_domain(domain_name, switch_event.getCPtr(arg1), SWIGTYPE_p_p_switch_xml.getCPtr(root), SWIGTYPE_p_p_switch_xml.getCPtr(domain));
    return ret;
  }

  public static switch_status_t switch_xml_locate_user(string key, string user_name, string domain_name, string ip, SWIGTYPE_p_p_switch_xml root, SWIGTYPE_p_p_switch_xml domain, SWIGTYPE_p_p_switch_xml user, switch_event arg7) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_xml_locate_user(key, user_name, domain_name, ip, SWIGTYPE_p_p_switch_xml.getCPtr(root), SWIGTYPE_p_p_switch_xml.getCPtr(domain), SWIGTYPE_p_p_switch_xml.getCPtr(user), switch_event.getCPtr(arg7));
    return ret;
  }

  public static switch_xml switch_xml_open_cfg(string file_path, SWIGTYPE_p_p_switch_xml node, switch_event arg2) {
    IntPtr cPtr = freeswitchPINVOKE.switch_xml_open_cfg(file_path, SWIGTYPE_p_p_switch_xml.getCPtr(node), switch_event.getCPtr(arg2));
    switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false);
    return ret;
  }

  public static switch_status_t switch_xml_bind_search_function(SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char_p_switch_event_t_p_void__p_switch_xml function, uint sections, SWIGTYPE_p_void user_data) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_xml_bind_search_function(SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char_p_switch_event_t_p_void__p_switch_xml.getCPtr(function), sections, SWIGTYPE_p_void.getCPtr(user_data));
    return ret;
  }

  public static uint switch_xml_parse_section_string(string str) {
    uint ret = freeswitchPINVOKE.switch_xml_parse_section_string(str);
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_outgoing_channel(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_unsigned_long__switch_status_t outgoing_channel) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_outgoing_channel(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_unsigned_long__switch_status_t.getCPtr(outgoing_channel));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_receive_message(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t receive_message) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_receive_message(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t.getCPtr(receive_message));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_receive_event(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t receive_event) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_receive_event(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t.getCPtr(receive_event));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_state_change(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session__switch_status_t state_change) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_state_change(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session__switch_status_t.getCPtr(state_change));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_read_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t read_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_read_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(read_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_write_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t write_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_write_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(write_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_video_read_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t video_read_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_video_read_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(video_read_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_video_write_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t video_write_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_video_write_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(video_write_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_kill_channel(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t kill_channel) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_kill_channel(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t.getCPtr(kill_channel));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_send_dtmf(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t send_dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_send_dtmf(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t.getCPtr(send_dtmf));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_recv_dtmf(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t recv_dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_recv_dtmf(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t.getCPtr(recv_dtmf));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_add_resurrect_session(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t resurrect_session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_add_resurrect_session(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t.getCPtr(resurrect_session));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_outgoing_channel(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_unsigned_long__switch_status_t outgoing_channel) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_outgoing_channel(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_unsigned_long__switch_status_t.getCPtr(outgoing_channel));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_receive_message(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t receive_message) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_receive_message(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t.getCPtr(receive_message));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_receive_event(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t receive_event) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_receive_event(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t.getCPtr(receive_event));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_state_change(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session__switch_status_t state_change) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_state_change(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session__switch_status_t.getCPtr(state_change));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_read_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t read_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_read_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(read_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_write_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t write_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_write_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(write_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_video_read_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t video_read_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_video_read_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(video_read_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_video_write_frame(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t video_write_frame) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_video_write_frame(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_unsigned_long_int__switch_status_t.getCPtr(video_write_frame));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_kill_channel(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t kill_channel) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_kill_channel(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t.getCPtr(kill_channel));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_send_dtmf(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t send_dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_send_dtmf(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t.getCPtr(send_dtmf));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_recv_dtmf(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t recv_dtmf) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_recv_dtmf(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t.getCPtr(recv_dtmf));
    return ret;
  }

  public static switch_status_t switch_core_event_hook_remove_resurrect_session(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t resurrect_session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_event_hook_remove_resurrect_session(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t.getCPtr(resurrect_session));
    return ret;
  }

  public static uint switch_scheduler_add_task(SWIGTYPE_p_time_t task_runtime, SWIGTYPE_p_f_p_switch_scheduler_task__void func, string desc, string group, uint cmd_id, SWIGTYPE_p_void cmd_arg, uint flags) {
    uint ret = freeswitchPINVOKE.switch_scheduler_add_task(SWIGTYPE_p_time_t.getCPtr(task_runtime), SWIGTYPE_p_f_p_switch_scheduler_task__void.getCPtr(func), desc, group, cmd_id, SWIGTYPE_p_void.getCPtr(cmd_arg), flags);
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static uint switch_scheduler_del_task_id(uint task_id) {
    uint ret = freeswitchPINVOKE.switch_scheduler_del_task_id(task_id);
    return ret;
  }

  public static uint switch_scheduler_del_task_group(string group) {
    uint ret = freeswitchPINVOKE.switch_scheduler_del_task_group(group);
    return ret;
  }

  public static void switch_scheduler_task_thread_start() {
    freeswitchPINVOKE.switch_scheduler_task_thread_start();
  }

  public static void switch_scheduler_task_thread_stop() {
    freeswitchPINVOKE.switch_scheduler_task_thread_stop();
  }

  public static int switch_config_open_file(switch_config cfg, string file_path) {
    int ret = freeswitchPINVOKE.switch_config_open_file(switch_config.getCPtr(cfg), file_path);
    return ret;
  }

  public static void switch_config_close_file(switch_config cfg) {
    freeswitchPINVOKE.switch_config_close_file(switch_config.getCPtr(cfg));
  }

  public static int switch_config_next_pair(switch_config cfg, SWIGTYPE_p_p_char var, SWIGTYPE_p_p_char val) {
    int ret = freeswitchPINVOKE.switch_config_next_pair(switch_config.getCPtr(cfg), SWIGTYPE_p_p_char.getCPtr(var), SWIGTYPE_p_p_char.getCPtr(val));
    return ret;
  }

  public static void consoleLog(string level_str, string msg) {
    freeswitchPINVOKE.consoleLog(level_str, msg);
  }

  public static void consoleCleanLog(string msg) {
    freeswitchPINVOKE.consoleCleanLog(msg);
  }

  public static void console_log(string level_str, string msg) {
    freeswitchPINVOKE.console_log(level_str, msg);
  }

  public static void console_clean_log(string msg) {
    freeswitchPINVOKE.console_clean_log(msg);
  }

  public static void bridge(CoreSession session_a, CoreSession session_b) {
    freeswitchPINVOKE.bridge(CoreSession.getCPtr(session_a), CoreSession.getCPtr(session_b));
    if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
  }

  public static switch_status_t hanguphook(SWIGTYPE_p_switch_core_session session) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.hanguphook(SWIGTYPE_p_switch_core_session.getCPtr(session));
    return ret;
  }

  public static switch_status_t dtmf_callback(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_void input, switch_input_type_t itype, SWIGTYPE_p_void buf, uint buflen) {
    switch_status_t ret = (switch_status_t)freeswitchPINVOKE.dtmf_callback(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_void.getCPtr(input), (int)itype, SWIGTYPE_p_void.getCPtr(buf), buflen);
    return ret;
  }

  public static readonly string FREESWITCH_PEN = freeswitchPINVOKE.FREESWITCH_PEN_get();
  public static readonly string FREESWITCH_OID_PREFIX = freeswitchPINVOKE.FREESWITCH_OID_PREFIX_get();
  public static readonly string FREESWITCH_ITAD = freeswitchPINVOKE.FREESWITCH_ITAD_get();
  public static readonly int __EXTENSIONS__ = freeswitchPINVOKE.__EXTENSIONS___get();
  public static readonly int __BSD_VISIBLE = freeswitchPINVOKE.__BSD_VISIBLE_get();
  public static readonly string SWITCH_BLANK_STRING = freeswitchPINVOKE.SWITCH_BLANK_STRING_get();
  public static readonly string SWITCH_SEQ_ESC = freeswitchPINVOKE.SWITCH_SEQ_ESC_get();
  public static readonly char SWITCH_SEQ_HOME_CHAR = freeswitchPINVOKE.SWITCH_SEQ_HOME_CHAR_get();
  public static readonly string SWITCH_SEQ_HOME_CHAR_STR = freeswitchPINVOKE.SWITCH_SEQ_HOME_CHAR_STR_get();
  public static readonly char SWITCH_SEQ_CLEARLINE_CHAR = freeswitchPINVOKE.SWITCH_SEQ_CLEARLINE_CHAR_get();
  public static readonly string SWITCH_SEQ_CLEARLINE_CHAR_STR = freeswitchPINVOKE.SWITCH_SEQ_CLEARLINE_CHAR_STR_get();
  public static readonly string SWITCH_SEQ_CLEARLINEEND_CHAR = freeswitchPINVOKE.SWITCH_SEQ_CLEARLINEEND_CHAR_get();
  public static readonly char SWITCH_SEQ_CLEARSCR_CHAR0 = freeswitchPINVOKE.SWITCH_SEQ_CLEARSCR_CHAR0_get();
  public static readonly char SWITCH_SEQ_CLEARSCR_CHAR1 = freeswitchPINVOKE.SWITCH_SEQ_CLEARSCR_CHAR1_get();
  public static readonly string SWITCH_SEQ_CLEARSCR_CHAR = freeswitchPINVOKE.SWITCH_SEQ_CLEARSCR_CHAR_get();
  public static readonly string SWITCH_SEQ_AND_COLOR = freeswitchPINVOKE.SWITCH_SEQ_AND_COLOR_get();
  public static readonly string SWITCH_SEQ_END_COLOR = freeswitchPINVOKE.SWITCH_SEQ_END_COLOR_get();
  public static readonly string SWITCH_SEQ_F_BLACK = freeswitchPINVOKE.SWITCH_SEQ_F_BLACK_get();
  public static readonly string SWITCH_SEQ_F_RED = freeswitchPINVOKE.SWITCH_SEQ_F_RED_get();
  public static readonly string SWITCH_SEQ_F_GREEN = freeswitchPINVOKE.SWITCH_SEQ_F_GREEN_get();
  public static readonly string SWITCH_SEQ_F_YELLOW = freeswitchPINVOKE.SWITCH_SEQ_F_YELLOW_get();
  public static readonly string SWITCH_SEQ_F_BLUE = freeswitchPINVOKE.SWITCH_SEQ_F_BLUE_get();
  public static readonly string SWITCH_SEQ_F_MAGEN = freeswitchPINVOKE.SWITCH_SEQ_F_MAGEN_get();
  public static readonly string SWITCH_SEQ_F_CYAN = freeswitchPINVOKE.SWITCH_SEQ_F_CYAN_get();
  public static readonly string SWITCH_SEQ_F_WHITE = freeswitchPINVOKE.SWITCH_SEQ_F_WHITE_get();
  public static readonly string SWITCH_SEQ_B_BLACK = freeswitchPINVOKE.SWITCH_SEQ_B_BLACK_get();
  public static readonly string SWITCH_SEQ_B_RED = freeswitchPINVOKE.SWITCH_SEQ_B_RED_get();
  public static readonly string SWITCH_SEQ_B_GREEN = freeswitchPINVOKE.SWITCH_SEQ_B_GREEN_get();
  public static readonly string SWITCH_SEQ_B_YELLOW = freeswitchPINVOKE.SWITCH_SEQ_B_YELLOW_get();
  public static readonly string SWITCH_SEQ_B_BLUE = freeswitchPINVOKE.SWITCH_SEQ_B_BLUE_get();
  public static readonly string SWITCH_SEQ_B_MAGEN = freeswitchPINVOKE.SWITCH_SEQ_B_MAGEN_get();
  public static readonly string SWITCH_SEQ_B_CYAN = freeswitchPINVOKE.SWITCH_SEQ_B_CYAN_get();
  public static readonly string SWITCH_SEQ_B_WHITE = freeswitchPINVOKE.SWITCH_SEQ_B_WHITE_get();
  public static readonly string SWITCH_SEQ_FBLACK = freeswitchPINVOKE.SWITCH_SEQ_FBLACK_get();
  public static readonly string SWITCH_SEQ_FRED = freeswitchPINVOKE.SWITCH_SEQ_FRED_get();
  public static readonly string SWITCH_SEQ_FGREEN = freeswitchPINVOKE.SWITCH_SEQ_FGREEN_get();
  public static readonly string SWITCH_SEQ_FYELLOW = freeswitchPINVOKE.SWITCH_SEQ_FYELLOW_get();
  public static readonly string SWITCH_SEQ_FBLUE = freeswitchPINVOKE.SWITCH_SEQ_FBLUE_get();
  public static readonly string SWITCH_SEQ_FMAGEN = freeswitchPINVOKE.SWITCH_SEQ_FMAGEN_get();
  public static readonly string SWITCH_SEQ_FCYAN = freeswitchPINVOKE.SWITCH_SEQ_FCYAN_get();
  public static readonly string SWITCH_SEQ_FWHITE = freeswitchPINVOKE.SWITCH_SEQ_FWHITE_get();
  public static readonly string SWITCH_SEQ_BBLACK = freeswitchPINVOKE.SWITCH_SEQ_BBLACK_get();
  public static readonly string SWITCH_SEQ_BRED = freeswitchPINVOKE.SWITCH_SEQ_BRED_get();
  public static readonly string SWITCH_SEQ_BGREEN = freeswitchPINVOKE.SWITCH_SEQ_BGREEN_get();
  public static readonly string SWITCH_SEQ_BYELLOW = freeswitchPINVOKE.SWITCH_SEQ_BYELLOW_get();
  public static readonly string SWITCH_SEQ_BBLUE = freeswitchPINVOKE.SWITCH_SEQ_BBLUE_get();
  public static readonly string SWITCH_SEQ_BMAGEN = freeswitchPINVOKE.SWITCH_SEQ_BMAGEN_get();
  public static readonly string SWITCH_SEQ_BCYAN = freeswitchPINVOKE.SWITCH_SEQ_BCYAN_get();
  public static readonly string SWITCH_SEQ_BWHITE = freeswitchPINVOKE.SWITCH_SEQ_BWHITE_get();
  public static readonly string SWITCH_SEQ_HOME = freeswitchPINVOKE.SWITCH_SEQ_HOME_get();
  public static readonly string SWITCH_SEQ_CLEARLINE = freeswitchPINVOKE.SWITCH_SEQ_CLEARLINE_get();
  public static readonly string SWITCH_SEQ_CLEARLINEEND = freeswitchPINVOKE.SWITCH_SEQ_CLEARLINEEND_get();
  public static readonly string SWITCH_SEQ_CLEARSCR = freeswitchPINVOKE.SWITCH_SEQ_CLEARSCR_get();
  public static readonly int SWITCH_DEFAULT_DTMF_DURATION = freeswitchPINVOKE.SWITCH_DEFAULT_DTMF_DURATION_get();
  public static readonly int SWITCH_MAX_DTMF_DURATION = freeswitchPINVOKE.SWITCH_MAX_DTMF_DURATION_get();
  public static readonly string SWITCH_PATH_SEPARATOR = freeswitchPINVOKE.SWITCH_PATH_SEPARATOR_get();
  public static readonly string SWITCH_URL_SEPARATOR = freeswitchPINVOKE.SWITCH_URL_SEPARATOR_get();
  public static readonly string SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE = freeswitchPINVOKE.SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_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_RING_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_RING_VARIABLE_get();
  public static readonly string SWITCH_CALL_TIMEOUT_VARIABLE = freeswitchPINVOKE.SWITCH_CALL_TIMEOUT_VARIABLE_get();
  public static readonly string SWITCH_HOLDING_UUID_VARIABLE = freeswitchPINVOKE.SWITCH_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_HANGUP_HOOK_VARIABLE = freeswitchPINVOKE.SWITCH_API_HANGUP_HOOK_VARIABLE_get();
  public static readonly string SWITCH_PROCESS_CDR_VARIABLE = freeswitchPINVOKE.SWITCH_PROCESS_CDR_VARIABLE_get();
  public static readonly string SWITCH_BRIDGE_CHANNEL_VARIABLE = freeswitchPINVOKE.SWITCH_BRIDGE_CHANNEL_VARIABLE_get();
  public static readonly string SWITCH_CHANNEL_NAME_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_NAME_VARIABLE_get();
  public static readonly string SWITCH_BRIDGE_UUID_VARIABLE = freeswitchPINVOKE.SWITCH_BRIDGE_UUID_VARIABLE_get();
  public static readonly string SWITCH_PLAYBACK_TERMINATORS_VARIABLE = freeswitchPINVOKE.SWITCH_PLAYBACK_TERMINATORS_VARIABLE_get();
  public static readonly string SWITCH_CACHE_SPEECH_HANDLES_VARIABLE = freeswitchPINVOKE.SWITCH_CACHE_SPEECH_HANDLES_VARIABLE_get();
  public static readonly string SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME = freeswitchPINVOKE.SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME_get();
  public static readonly string SWITCH_BYPASS_MEDIA_VARIABLE = freeswitchPINVOKE.SWITCH_BYPASS_MEDIA_VARIABLE_get();
  public static readonly string SWITCH_PROXY_MEDIA_VARIABLE = freeswitchPINVOKE.SWITCH_PROXY_MEDIA_VARIABLE_get();
  public static readonly string SWITCH_ENDPOINT_DISPOSITION_VARIABLE = freeswitchPINVOKE.SWITCH_ENDPOINT_DISPOSITION_VARIABLE_get();
  public static readonly string SWITCH_HOLD_MUSIC_VARIABLE = freeswitchPINVOKE.SWITCH_HOLD_MUSIC_VARIABLE_get();
  public static readonly string SWITCH_EXPORT_VARS_VARIABLE = freeswitchPINVOKE.SWITCH_EXPORT_VARS_VARIABLE_get();
  public static readonly string SWITCH_R_SDP_VARIABLE = freeswitchPINVOKE.SWITCH_R_SDP_VARIABLE_get();
  public static readonly string SWITCH_L_SDP_VARIABLE = freeswitchPINVOKE.SWITCH_L_SDP_VARIABLE_get();
  public static readonly string SWITCH_B_SDP_VARIABLE = freeswitchPINVOKE.SWITCH_B_SDP_VARIABLE_get();
  public static readonly string SWITCH_BRIDGE_VARIABLE = freeswitchPINVOKE.SWITCH_BRIDGE_VARIABLE_get();
  public static readonly string SWITCH_SIGNAL_BRIDGE_VARIABLE = freeswitchPINVOKE.SWITCH_SIGNAL_BRIDGE_VARIABLE_get();
  public static readonly string SWITCH_SIGNAL_BOND_VARIABLE = freeswitchPINVOKE.SWITCH_SIGNAL_BOND_VARIABLE_get();
  public static readonly string SWITCH_ORIGINATOR_VARIABLE = freeswitchPINVOKE.SWITCH_ORIGINATOR_VARIABLE_get();
  public static readonly string SWITCH_ORIGINATOR_CODEC_VARIABLE = freeswitchPINVOKE.SWITCH_ORIGINATOR_CODEC_VARIABLE_get();
  public static readonly string SWITCH_LOCAL_MEDIA_IP_VARIABLE = freeswitchPINVOKE.SWITCH_LOCAL_MEDIA_IP_VARIABLE_get();
  public static readonly string SWITCH_LOCAL_MEDIA_PORT_VARIABLE = freeswitchPINVOKE.SWITCH_LOCAL_MEDIA_PORT_VARIABLE_get();
  public static readonly string SWITCH_REMOTE_MEDIA_IP_VARIABLE = freeswitchPINVOKE.SWITCH_REMOTE_MEDIA_IP_VARIABLE_get();
  public static readonly string SWITCH_REMOTE_MEDIA_PORT_VARIABLE = freeswitchPINVOKE.SWITCH_REMOTE_MEDIA_PORT_VARIABLE_get();
  public static readonly string SWITCH_REMOTE_VIDEO_IP_VARIABLE = freeswitchPINVOKE.SWITCH_REMOTE_VIDEO_IP_VARIABLE_get();
  public static readonly string SWITCH_REMOTE_VIDEO_PORT_VARIABLE = freeswitchPINVOKE.SWITCH_REMOTE_VIDEO_PORT_VARIABLE_get();
  public static readonly string SWITCH_LOCAL_VIDEO_IP_VARIABLE = freeswitchPINVOKE.SWITCH_LOCAL_VIDEO_IP_VARIABLE_get();
  public static readonly string SWITCH_LOCAL_VIDEO_PORT_VARIABLE = freeswitchPINVOKE.SWITCH_LOCAL_VIDEO_PORT_VARIABLE_get();
  public static readonly string SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE = freeswitchPINVOKE.SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE_get();
  public static readonly string SWITCH_EXEC_AFTER_BRIDGE_APP_VARIABLE = freeswitchPINVOKE.SWITCH_EXEC_AFTER_BRIDGE_APP_VARIABLE_get();
  public static readonly string SWITCH_EXEC_AFTER_BRIDGE_ARG_VARIABLE = freeswitchPINVOKE.SWITCH_EXEC_AFTER_BRIDGE_ARG_VARIABLE_get();
  public static readonly string SWITCH_MAX_FORWARDS_VARIABLE = freeswitchPINVOKE.SWITCH_MAX_FORWARDS_VARIABLE_get();
  public static readonly string SWITCH_DISABLE_APP_LOG_VARIABLE = freeswitchPINVOKE.SWITCH_DISABLE_APP_LOG_VARIABLE_get();
  public static readonly string SWITCH_SPEECH_KEY = freeswitchPINVOKE.SWITCH_SPEECH_KEY_get();
  public static readonly string SWITCH_UUID_BRIDGE = freeswitchPINVOKE.SWITCH_UUID_BRIDGE_get();
  public static readonly int SWITCH_BITS_PER_BYTE = freeswitchPINVOKE.SWITCH_BITS_PER_BYTE_get();
  public static readonly int SWITCH_MAX_STACKS = freeswitchPINVOKE.SWITCH_MAX_STACKS_get();
  public static readonly int SWITCH_THREAD_STACKSIZE = freeswitchPINVOKE.SWITCH_THREAD_STACKSIZE_get();
  public static readonly int SWITCH_MAX_INTERVAL = freeswitchPINVOKE.SWITCH_MAX_INTERVAL_get();
  public static readonly int SWITCH_INTERVAL_PAD = freeswitchPINVOKE.SWITCH_INTERVAL_PAD_get();
  public static readonly int SWITCH_MAX_SAMPLE_LEN = freeswitchPINVOKE.SWITCH_MAX_SAMPLE_LEN_get();
  public static readonly int SWITCH_BYTES_PER_SAMPLE = freeswitchPINVOKE.SWITCH_BYTES_PER_SAMPLE_get();
  public static readonly int SWITCH_RECOMMENDED_BUFFER_SIZE = freeswitchPINVOKE.SWITCH_RECOMMENDED_BUFFER_SIZE_get();
  public static readonly int SWITCH_MAX_CODECS = freeswitchPINVOKE.SWITCH_MAX_CODECS_get();
  public static readonly int SWITCH_MAX_STATE_HANDLERS = freeswitchPINVOKE.SWITCH_MAX_STATE_HANDLERS_get();
  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_API_VERSION = freeswitchPINVOKE.SWITCH_API_VERSION_get();
  public static readonly int SWITCH_CORE_DB_OK = freeswitchPINVOKE.SWITCH_CORE_DB_OK_get();
  public static readonly int SWITCH_CORE_DB_ERROR = freeswitchPINVOKE.SWITCH_CORE_DB_ERROR_get();
  public static readonly int SWITCH_CORE_DB_INTERNAL = freeswitchPINVOKE.SWITCH_CORE_DB_INTERNAL_get();
  public static readonly int SWITCH_CORE_DB_PERM = freeswitchPINVOKE.SWITCH_CORE_DB_PERM_get();
  public static readonly int SWITCH_CORE_DB_ABORT = freeswitchPINVOKE.SWITCH_CORE_DB_ABORT_get();
  public static readonly int SWITCH_CORE_DB_BUSY = freeswitchPINVOKE.SWITCH_CORE_DB_BUSY_get();
  public static readonly int SWITCH_CORE_DB_LOCKED = freeswitchPINVOKE.SWITCH_CORE_DB_LOCKED_get();
  public static readonly int SWITCH_CORE_DB_NOMEM = freeswitchPINVOKE.SWITCH_CORE_DB_NOMEM_get();
  public static readonly int SWITCH_CORE_DB_READONLY = freeswitchPINVOKE.SWITCH_CORE_DB_READONLY_get();
  public static readonly int SWITCH_CORE_DB_INTERRUPT = freeswitchPINVOKE.SWITCH_CORE_DB_INTERRUPT_get();
  public static readonly int SWITCH_CORE_DB_IOERR = freeswitchPINVOKE.SWITCH_CORE_DB_IOERR_get();
  public static readonly int SWITCH_CORE_DB_CORRUPT = freeswitchPINVOKE.SWITCH_CORE_DB_CORRUPT_get();
  public static readonly int SWITCH_CORE_DB_NOTFOUND = freeswitchPINVOKE.SWITCH_CORE_DB_NOTFOUND_get();
  public static readonly int SWITCH_CORE_DB_FULL = freeswitchPINVOKE.SWITCH_CORE_DB_FULL_get();
  public static readonly int SWITCH_CORE_DB_CANTOPEN = freeswitchPINVOKE.SWITCH_CORE_DB_CANTOPEN_get();
  public static readonly int SWITCH_CORE_DB_PROTOCOL = freeswitchPINVOKE.SWITCH_CORE_DB_PROTOCOL_get();
  public static readonly int SWITCH_CORE_DB_EMPTY = freeswitchPINVOKE.SWITCH_CORE_DB_EMPTY_get();
  public static readonly int SWITCH_CORE_DB_SCHEMA = freeswitchPINVOKE.SWITCH_CORE_DB_SCHEMA_get();
  public static readonly int SWITCH_CORE_DB_TOOBIG = freeswitchPINVOKE.SWITCH_CORE_DB_TOOBIG_get();
  public static readonly int SWITCH_CORE_DB_CONSTRAINT = freeswitchPINVOKE.SWITCH_CORE_DB_CONSTRAINT_get();
  public static readonly int SWITCH_CORE_DB_MISMATCH = freeswitchPINVOKE.SWITCH_CORE_DB_MISMATCH_get();
  public static readonly int SWITCH_CORE_DB_MISUSE = freeswitchPINVOKE.SWITCH_CORE_DB_MISUSE_get();
  public static readonly int SWITCH_CORE_DB_NOLFS = freeswitchPINVOKE.SWITCH_CORE_DB_NOLFS_get();
  public static readonly int SWITCH_CORE_DB_AUTH = freeswitchPINVOKE.SWITCH_CORE_DB_AUTH_get();
  public static readonly int SWITCH_CORE_DB_FORMAT = freeswitchPINVOKE.SWITCH_CORE_DB_FORMAT_get();
  public static readonly int SWITCH_CORE_DB_RANGE = freeswitchPINVOKE.SWITCH_CORE_DB_RANGE_get();
  public static readonly int SWITCH_CORE_DB_NOTADB = freeswitchPINVOKE.SWITCH_CORE_DB_NOTADB_get();
  public static readonly int SWITCH_CORE_DB_ROW = freeswitchPINVOKE.SWITCH_CORE_DB_ROW_get();
  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 SWITCH_CORE_DB = freeswitchPINVOKE.SWITCH_CORE_DB_get();
  public static readonly int SWITCH_CMD_CHUNK_LEN = freeswitchPINVOKE.SWITCH_CMD_CHUNK_LEN_get();
  public static readonly int SWITCH_SMAX = freeswitchPINVOKE.SWITCH_SMAX_get();
  public static readonly int SWITCH_SMIN = freeswitchPINVOKE.SWITCH_SMIN_get();
  public static readonly int SWITCH_RTP_MAX_BUF_LEN = freeswitchPINVOKE.SWITCH_RTP_MAX_BUF_LEN_get();
  public static readonly int SWITCH_RTP_MAX_CRYPTO_LEN = freeswitchPINVOKE.SWITCH_RTP_MAX_CRYPTO_LEN_get();
  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 SWITCH_XML_BUFSIZE = freeswitchPINVOKE.SWITCH_XML_BUFSIZE_get();
}

}
