add the new mod_mono first draft from MichaelGG into tree.

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@8656 d0543943-73ff-0310-b7d9-9358b9ac24b2
2026-10-10 05:14:20 +00:00 · 2008-05-26 03:43:49 +00:00
1 parent aa93dc3e9c
commit 761dcb6952
@@ -0,0 +1,105 @@
+%module freeswitch
+
+/** insert the following includes into generated code so it compiles */
+%{
+#include "switch.h"
+#include "switch_cpp.h"
+#include "freeswitch_mono.h"
+%}
+
+%typemap(csclassmodifiers) MonoSession "public partial class"
+%typemap(csclassmodifiers) Event "public partial class"
+%typemap(csclassmodifiers) Stream "public partial class"
+
+// Some things we dont want exposed to managed users directly, since 
+// we're gonna handle them with our own internalcall methods
+%ignore dtmfDelegateHandle;
+%ignore hangupDelegateHandle;
+%ignore setHangupHook;
+%ignore beginAllowThreads;
+%ignore endAllowThreads;
+%ignore process_callback_result;
+%ignore run_dtmf_callback;
+%ignore setDTMFCallback;
+
+// Rename some things to make them more .NET-like
+%rename (Answer) CoreSession::answer;
+%rename (Hangup) CoreSession::hangup;
+%rename (Ready) CoreSession::ready;
+%rename (Transfer) CoreSession::transfer;
+%rename (Originate) CoreSession::originate;
+%rename (SetVariable) CoreSession::setVariable;
+%rename (GetVariable) CoreSession::getVariable;
+%rename (SetPrivate) CoreSession::setPrivate;
+%rename (GetPrivate) CoreSession::getPrivate;
+%rename (Say) CoreSession::say;
+%rename (SayPhrase) CoreSession::sayPhrase;
+%rename (RecordFile) CoreSession::recordFile;
+%rename (SetCallerData) CoreSession::setCallerData;
+%rename (CollectDigits) CoreSession::collectDigits;
+%rename (GetDigits) CoreSession::getDigits;
+%rename (PlayAndGetDigits) CoreSession::playAndGetDigits;
+%rename (StreamFile) CoreSession::streamFile;
+%rename (Execute) CoreSession::execute;
+%rename (GetUuid) CoreSession::get_uuid;
+%rename (HookState) CoreSession::hook_state;
+%rename (InternalSession) CoreSession::session;
+
+%rename (Serialize) Event::serialize;
+%rename (SetPriority) Event::setPriority;
+%rename (GetHeader) Event::getHeader;
+%rename (GetBody) Event::getBody;
+%rename (GetEventType) Event::getType;
+%rename (AddBody) Event::addBody;
+%rename (AddHeader) Event::addHeader;
+%rename (DeleteHeader) Event::delHeader;
+%rename (Fire) Event::fire;
+%rename (InternalEvent) Event::event;
+
+%rename (Write) Stream::write;
+%rename (GetData) Stream::getData;
+
+%rename (Api) API;
+%rename (Execute) API::execute;
+%rename (ExecuteString) API::executeString;
+
+%rename (IvrMenu) IVRMenu;
+%rename (Execute) IVRMenu::execute;
+%rename (ExecuteString) API::executeString;
+
+// Causes C2564, todo
+%ignore switch_ivr_menu_action_function_t;
+// todo, other errors
+%ignore switch_core_session_get_event_hooks;
+%ignore switch_inet_pton;
+%ignore switch_xml_idx;
+
+// Real header includes now
+%import switch_platform.i // This will give us all the macros we need to compile the other stuff
+
+%include switch.h
+%include switch_types.h
+
+%include switch_core_db.h
+%include switch_regex.h
+%include switch_core.h
+//%include switch_loadable_module.h // todo: Sort out some linking issues
+%include switch_console.h // Has unsupported varargs functions
+%include switch_utils.h
+%include switch_caller.h
+%include switch_frame.h
+%include switch_module_interfaces.h
+%include switch_channel.h
+%include switch_buffer.h
+%include switch_event.h // Varargs omitted
+%include switch_resample.h
+%include switch_ivr.h
+%include switch_rtp.h
+%include switch_log.h // switch_log_printf is omitted (varargs)
+%include switch_xml.h
+%include switch_core_event_hook.h
+%include switch_scheduler.h
+%include switch_config.h
+
+%include switch_cpp.h
+%include freeswitch_mono.h
@@ -0,0 +1,114 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * freeswitch_mono.cpp -- Mono-specific CoreSession subclass
+ *
+ */
+
+#include <switch.h>
+#include <switch_cpp.h>
+#include <glib.h>
+#include <mono/jit/jit.h>
+#include <mono/metadata/assembly.h>
+#include <mono/metadata/environment.h>
+#include <mono/metadata/threads.h>
+#include <mono/metadata/metadata.h>
+#include "freeswitch_mono.h"
+
+MonoSession::MonoSession() : CoreSession() 
+{
+}
+
+MonoSession::MonoSession(char *uuid) : CoreSession(uuid)
+{
+}
+
+MonoSession::MonoSession(switch_core_session_t *session) : CoreSession(session)
+{
+}
+
+MonoSession::~MonoSession()
+{
+	mono_thread_attach(globals.domain);
+	if (dtmfDelegateHandle) mono_gchandle_free(dtmfDelegateHandle);
+	if (hangupDelegateHandle) mono_gchandle_free(hangupDelegateHandle);
+}
+
+bool MonoSession::begin_allow_threads()
+{
+    return true;
+}
+
+bool MonoSession::end_allow_threads()
+{
+    return true;
+}
+
+void MonoSession::check_hangup_hook()  
+{
+	mono_thread_attach(globals.domain);
+	if (!hangupDelegateHandle) {
+		return;
+	}
+	MonoObject *hangupDelegate = mono_gchandle_get_target(hangupDelegateHandle);
+	if (!hangupDelegate) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "hangupDelegateHandle didn't get an object.");
+		return;
+	}
+	MonoObject *ex = NULL;
+	mono_runtime_delegate_invoke(hangupDelegate, NULL, &ex);
+	if (ex) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "hangupDelegate threw an exception.");
+	}
+}
+
+switch_status_t MonoSession::run_dtmf_callback(void *input, switch_input_type_t itype)
+{
+	mono_thread_attach(globals.domain);
+	if (!dtmfDelegateHandle) {
+		return SWITCH_STATUS_SUCCESS;
+	}
+	MonoObject *dtmfDelegate = mono_gchandle_get_target(dtmfDelegateHandle);
+	if (!dtmfDelegate) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "dtmfDelegateHandle didn't get an object.");
+		return SWITCH_STATUS_SUCCESS;
+	}
+	void *args[2];
+	args[0] = &input;
+	args[1] = &itype;
+	MonoObject *ex = NULL;
+	MonoObject *res = mono_runtime_delegate_invoke(dtmfDelegate, args, &ex);
+	if (ex) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "dtmfDelegate threw an exception.");
+		return SWITCH_STATUS_FALSE;
+	}
+	char *resPtr = mono_string_to_utf8((MonoString*)res);
+	switch_status_t status = process_callback_result(resPtr);
+
+	g_free(resPtr);
+	return status;
+}
@@ -0,0 +1,79 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * freeswitch_mono.h -- Header for MonoSession and globals
+ *
+ */
+
+#ifndef FREESWITCH_MONO_H
+#define FREESWITCH_MONO_H
+
+SWITCH_BEGIN_EXTERN_C
+
+#include <switch.h>
+#include <switch_cpp.h>
+#include <mono/jit/jit.h>
+#include <mono/metadata/assembly.h>
+
+#ifndef SWIG
+struct mod_mono_globals {
+	MonoDomain *domain;
+	MonoAssembly *mod_mono_asm;
+	switch_memory_pool_t *pool;
+
+	MonoMethod *loadMethod;
+	MonoMethod *unloadMethod;
+	MonoMethod *runMethod;
+	MonoMethod *executeMethod;
+	MonoMethod *executeBackgroundMethod;
+};
+
+typedef struct mod_mono_globals mod_mono_globals;
+extern mod_mono_globals globals;
+#endif
+
+SWITCH_END_EXTERN_C
+
+class MonoSession : public CoreSession 
+{
+public:
+	MonoSession();
+	MonoSession(char *uuid);
+	MonoSession(switch_core_session_t *session);
+	~MonoSession();        
+
+	virtual bool begin_allow_threads();
+	virtual bool end_allow_threads();
+	virtual void check_hangup_hook();
+
+	virtual switch_status_t run_dtmf_callback(void *input, switch_input_type_t itype);
+
+	guint32 dtmfDelegateHandle; // GCHandle to the input delegate 
+	guint32 hangupDelegateHandle; // GCHandle to the hangup delegate
+};
+
+#endif
@@ -0,0 +1,327 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * mod_mono.cpp -- FreeSWITCH mod_mono main class
+ *
+ * Most of mod_mono is implmented in the mod_mono_managed Loader class. 
+ * The native code just handles getting the Mono runtime up and down
+ * and passing pointers into managed code.
+ */
+
+#include <switch.h>
+
+
+SWITCH_BEGIN_EXTERN_C
+
+#include "freeswitch_mono.h"
+#include <glib.h>
+#include <mono/jit/jit.h>
+#include <mono/metadata/assembly.h>
+#include <mono/metadata/environment.h>
+#include <mono/metadata/threads.h>
+#include <mono/metadata/debug-helpers.h>
+
+#ifdef WIN32
+#include <shlobj.h>
+#define EXPORT __declspec(dllexport)
+#elif
+#define EXPORT 
+#endif
+
+#define MOD_MONO_MANAGED_DLL "mod_mono_managed.dll"
+
+mod_mono_globals globals = { 0 };
+
+SWITCH_MODULE_LOAD_FUNCTION(mod_mono_load);
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_mono_shutdown);
+SWITCH_MODULE_DEFINITION(mod_mono, mod_mono_load, mod_mono_shutdown, NULL);
+
+SWITCH_STANDARD_API(monorun_api_function); /* ExecuteBackground */
+SWITCH_STANDARD_API(mono_api_function); /* Execute */
+SWITCH_STANDARD_APP(mono_app_function); /* Run */
+
+
+// Sets up delegates (and anything else needed) on the MonoSession object
+// Called via internalcall
+SWITCH_MOD_DECLARE(void) InitMonoSession(MonoSession *session, MonoObject *dtmfDelegate, MonoObject *hangupDelegate)
+{
+	switch_assert(session);
+	if (!session) return;
+	session->setDTMFCallback(NULL, "");
+	session->setHangupHook(NULL);
+	session->dtmfDelegateHandle = mono_gchandle_new(dtmfDelegate, FALSE);
+	session->hangupDelegateHandle = mono_gchandle_new(hangupDelegate, FALSE);
+}
+
+switch_status_t setMonoDirs() 
+{
+#ifdef WIN32	
+	/* Win32 Mono installs can't figure out their own path
+	// Guys in #mono say we should just deploy all the libs we need
+	// I think it's much nicer to let the user deal with installing Mono
+	// and we'll just look for it in program files. */
+	HANDLE hFind;
+	WIN32_FIND_DATA findData;
+	char progFilesPath[MAX_PATH];
+	char findPath[MAX_PATH];
+	SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES, NULL, SHGFP_TYPE_CURRENT, progFilesPath);
+	switch_snprintf(findPath, MAX_PATH, "%s\\Mono-*", progFilesPath);
+	hFind = FindFirstFile(findPath, &findData);
+	if (hFind == INVALID_HANDLE_VALUE) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error looking for Mono in Program Files.\n");
+		return SWITCH_STATUS_FALSE;
+	}
+	while((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY) {
+		if (FindNextFile(hFind, &findData) == 0) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not find Mono directory in Program Files.\n");
+			FindClose(hFind);
+			return SWITCH_STATUS_FALSE;
+		}
+	}
+	/* Got it */
+	{
+		char libPath[MAX_PATH];
+		char etcPath[MAX_PATH];
+		switch_snprintf(libPath, MAX_PATH, "%s\\%s\\lib", progFilesPath, findData.cFileName);
+		switch_snprintf(etcPath, MAX_PATH, "%s\\%s\\etc", progFilesPath, findData.cFileName);
+		FindClose(hFind);
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Using Mono paths '%s' and '%s'.\n", libPath, etcPath);
+		mono_set_dirs(libPath, etcPath);
+		return SWITCH_STATUS_SUCCESS;
+	}
+#elif
+	// On other platforms, it should just work if it hasn't been relocated
+	mono_set_dirs(NULL, NULL);
+	return SWITCH_STATUS_SUCCESS;
+#endif
+}
+
+switch_status_t loadModMonoManaged() 
+{ 
+	/* Find and load mod_mono_managed.exe */
+	char filename[256];
+	switch_snprintf(filename, 256, "%s%s%s", SWITCH_GLOBAL_dirs.mod_dir, SWITCH_PATH_SEPARATOR, MOD_MONO_MANAGED_DLL);
+	globals.domain = mono_jit_init(filename);
+
+	if (!globals.domain) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mono_jit_init failed.\n");
+		return SWITCH_STATUS_FALSE;
+	}
+
+	/* Open the assembly */
+	globals.mod_mono_asm = mono_domain_assembly_open(globals.domain, filename);
+	if (!globals.mod_mono_asm) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mono_domain_assembly_open failed.\n");
+		return SWITCH_STATUS_FALSE;
+	}
+	return SWITCH_STATUS_SUCCESS;
+}
+
+MonoMethod *getMethod(const char *name, MonoClass *klass) 
+{
+	MonoMethodDesc *desc;
+	MonoMethod *method;
+	desc = mono_method_desc_new(name, TRUE);
+	method = mono_method_desc_search_in_class(desc, klass);
+	if (!method) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not find %s method.\n", name);
+		return NULL;
+	}
+	return method;
+}
+
+switch_status_t findLoader() 
+{
+	/* Find loader class and methods*/
+	MonoImage* img;
+	MonoClass* loaderClass;
+	img = mono_assembly_get_image(globals.mod_mono_asm);
+	loaderClass = mono_class_from_name(img, "FreeSWITCH", "Loader");
+	if (!loaderClass) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not find FreeSWITCH.Loader class.\n");
+		return SWITCH_STATUS_FALSE;
+	}
+
+	globals.loadMethod = getMethod("FreeSWITCH.Loader:Load()", loaderClass);
+	if (!globals.loadMethod) return SWITCH_STATUS_FALSE;
+
+	globals.unloadMethod = getMethod("FreeSWITCH.Loader:Unload()", loaderClass);
+	if (!globals.unloadMethod) return SWITCH_STATUS_FALSE;
+
+	globals.runMethod = getMethod("FreeSWITCH.Loader:Run(string,intptr)", loaderClass);
+	if (!globals.runMethod) return SWITCH_STATUS_FALSE;
+
+	globals.executeMethod = getMethod("FreeSWITCH.Loader:Execute(string,intptr,intptr)", loaderClass);
+	if (!globals.executeMethod) return SWITCH_STATUS_FALSE;
+	
+	globals.executeBackgroundMethod = getMethod("FreeSWITCH.Loader:ExecuteBackground(string)", loaderClass);
+	if (!globals.executeBackgroundMethod) return SWITCH_STATUS_FALSE;
+
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Found all loader functions.\n");
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_MODULE_LOAD_FUNCTION(mod_mono_load) 
+{
+	/* connect my internal structure to the blank pointer passed to me */
+	*module_interface = switch_loadable_module_create_module_interface(pool, modname);
+	globals.pool = pool;
+
+	if (setMonoDirs() != SWITCH_STATUS_SUCCESS) {
+		return SWITCH_STATUS_FALSE;
+	}
+	if (loadModMonoManaged() != SWITCH_STATUS_SUCCESS) {
+		return SWITCH_STATUS_FALSE;
+	}
+	if (findLoader() != SWITCH_STATUS_SUCCESS) {
+		return SWITCH_STATUS_FALSE;
+	}
+		
+	/* Not sure if this is necesary on the loading thread */
+	mono_thread_attach(globals.domain);
+	mono_add_internal_call("FreeSWITCH.Native.MonoSession::InitMonoSession", InitMonoSession);
+
+	/* Run loader */
+	MonoObject *objResult;
+	MonoObject *exception = NULL;
+	objResult = mono_runtime_invoke(globals.loadMethod, NULL, NULL, &exception);
+	if (exception) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Load threw an exception.\n");
+		mono_print_unhandled_exception(exception);
+		return SWITCH_STATUS_FALSE;
+	}
+	if (*(int*)mono_object_unbox(objResult)) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Load completed successfully.\n");
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Load did not return true.\n");
+		return SWITCH_STATUS_FALSE;
+	}
+
+
+	/* We're good to register */
+	switch_api_interface_t *api_interface;
+	switch_application_interface_t *app_interface;
+
+	SWITCH_ADD_API(api_interface, "monorun", "Run a module (ExecuteBackground)", monorun_api_function, "<module> [<args>]");
+	SWITCH_ADD_API(api_interface, "mono", "Run a module as an API function (Execute)", mono_api_function, "<module> [<args>]");
+	SWITCH_ADD_APP(app_interface, "mono", "Run Mono IVR", "Run a Mono IVR on a channel", mono_app_function, "<modulename> [<args>]", SAF_NONE);
+	
+	return SWITCH_STATUS_SUCCESS;	
+}
+
+SWITCH_STANDARD_API(monorun_api_function) 
+{
+	// TODO: Should we be detaching after all this?
+	mono_thread_attach(globals.domain);
+	if (switch_strlen_zero(cmd)) {
+		stream->write_function(stream, "-ERR no args specified!\n");
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	// ExecuteBackground(string command)
+	void *args[1];
+	args[0] = mono_string_new(globals.domain, cmd);
+	MonoObject *exception = NULL;
+	MonoObject *objResult = mono_runtime_invoke(globals.executeBackgroundMethod, NULL, args, &exception);
+	if (exception) {
+		stream->write_function(stream, "-ERR FreeSWITCH.Loader.ExecuteBackground threw an exception.\n");
+		mono_print_unhandled_exception(exception);
+		return SWITCH_STATUS_SUCCESS;
+	}
+	if (*(int*)mono_object_unbox(objResult)) {
+		stream->write_function(stream, "+OK\n");
+	} else {
+		stream->write_function(stream, "-ERR ExecuteBackground returned false (unknown module?).\n");
+	}
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_STANDARD_API(mono_api_function)
+{
+	mono_thread_attach(globals.domain);
+	if (switch_strlen_zero(cmd)) {
+		stream->write_function(stream, "-ERR no args specified!\n");
+		return SWITCH_STATUS_SUCCESS;
+	}
+	
+	// Method is: Execute(string command, IntPtr streamPtr, IntPtr eventPtr)
+	void *args[3];
+	args[0] = mono_string_new(globals.domain, cmd);
+	args[1] = &stream; // Address of the arguments
+	args[2] = &(stream->param_event);
+	
+	MonoObject *exception = NULL;
+	MonoObject *objResult = mono_runtime_invoke(globals.executeMethod, NULL, args, &exception);
+	if (exception) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Exception trying to execute mono %s.\n", cmd);
+		mono_print_unhandled_exception(exception);
+	}
+	if (!(*(int*)mono_object_unbox(objResult))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Execute failed for %s (unknown module?).\n", cmd);
+	}
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_STANDARD_APP(mono_app_function)
+{
+	mono_thread_attach(globals.domain);
+	if (switch_strlen_zero(data)) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No args specified!\n");
+	}
+
+	// bool Run(string command, IntPtr sessionHandle)
+	void *args[2];
+	args[0] = mono_string_new(globals.domain, data);
+	args[1] = &session;
+
+	MonoObject *exception = NULL;
+	MonoObject *objResult = mono_runtime_invoke(globals.runMethod, NULL, args, &exception);
+	if (exception) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Exception trying to execute application mono %s.\n", data);
+		mono_print_unhandled_exception(exception);
+	}
+	if (!(*(int*)mono_object_unbox(objResult))) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Application run failed for %s (unknown module?).\n", data);
+	}
+}
+
+SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_mono_shutdown)
+{
+	mono_thread_attach(globals.domain);
+	MonoObject *ex;
+	mono_runtime_invoke(globals.unloadMethod, NULL, NULL, &ex);
+	if (ex) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Exception occurred in Loader::Unload.\n");
+		mono_print_unhandled_exception(ex);
+	}
+	mono_runtime_set_shutting_down();
+	mono_runtime_cleanup(globals.domain);
+	mono_runtime_quit();
+	return SWITCH_STATUS_SUCCESS;
+}
+
+SWITCH_END_EXTERN_C
@@ -0,0 +1,217 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="mod_mono"
+	ProjectGUID="{13DB4131-0142-4CAE-A14B-D6726B14A1BC}"
+	RootNamespace="mod_mono"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			InheritedPropertySheets="..\..\..\..\w32\module_debug.vsprops"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="&quot;C:\Program Files\Mono-1.9.1\lib\glib-2.0\include&quot;;&quot;C:\Program Files\Mono-1.9.1\include\glib-2.0&quot;;&quot;C:\Program Files\Mono-1.9.1\include\mono-1.0&quot;"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;MOD_MONO_EXPORTS"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="4"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+				DisableSpecificWarnings="4505"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="$(ProjectDir)mono.lib &quot;C:\program Files\Mono-1.9.1\lib\glib-2.0.lib&quot; shlwapi.lib"
+				LinkIncremental="2"
+				ModuleDefinitionFile=""
+				GenerateDebugInformation="true"
+				SubSystem="0"
+				DataExecutionPrevention="1"
+				TargetMachine="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;MOD_MONO_EXPORTS"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				ModuleDefinitionFile="mono.def"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\freeswitch_mono.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\freeswitch_wrap.cxx"
+				>
+			</File>
+			<File
+				RelativePath=".\mod_mono.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\freeswitch_mono.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<File
+			RelativePath=".\freeswitch.i"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
@@ -0,0 +1,3 @@
+\dev\swig\swig.exe -I..\..\..\include -v -O -c++ -csharp -namespace FreeSWITCH.Native -dllimport mod_mono freeswitch.i 
+move *.cs ..\mod_mono_managed\swig\ 
+..\mod_mono_managed\swigStringFix ..\mod_mono_managed\swig\freeswitchPINVOKE.cs > ..\mod_mono_managed\swig\freeswitchPINVOKE_fixed.cs
@@ -0,0 +1,45 @@
+// MANUALLY GENERATED
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned long uint32_t;
+typedef unsigned long long uint64_t;
+typedef signed char int8_t;
+typedef short int16_t;
+typedef int int32_t;
+typedef long long int64_t;
+typedef unsigned long in_addr_t;
+
+// TODO: C# chars are 2 bytes, C is one. The marshalling copies two bytes (Value+whatever) into the C# char
+//		causing corruption. We should figure this out. It's as simple as ((char)(byte)<thebyte>) whever
+//		we define char as byte.
+// TODO: Possible? It'd be nice to do the whole char*->IntPtr->Marshal/Free thing here instead of swigStringFix
+
+#define SWITCH_DECLARE(type) type
+#define SWITCH_DECLARE_NONSTD(type) type
+#define SWITCH_MOD_DECLARE(type) type
+#define SWITCH_DECLARE_DATA
+#define SWITCH_MOD_DECLARE_DATA
+#define SWITCH_THREAD_FUNC
+#define SWITCH_DECLARE_CONSTRUCTOR SWITCH_DECLARE_DATA
+
+#define _In_
+#define _In_z_
+#define _In_opt_z_
+#define _In_opt_
+#define _Printf_format_string_
+#define _Ret_opt_z_
+#define _Ret_z_
+#define _Out_opt_
+#define _Out_
+#define _Check_return_
+#define _Inout_
+#define _Inout_opt_
+#define _In_bytecount_(x)
+#define _Out_opt_bytecapcount_(x)
+#define _Out_bytecapcount_(x)
+#define _Ret_
+#define _Post_z_
+#define _Out_cap_(x)
+#define _Out_z_cap_(x)
+#define _Out_ptrdiff_cap_(x)
+#define _Out_opt_ptrdiff_cap_(x)
@@ -0,0 +1,49 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * AppFunction.cs -- Base class for API functions
+ *
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH
+{
+    public abstract class ApiFunction
+    {
+        protected static bool Load() { return true; }
+
+        protected static void Unload() { }
+
+        public abstract void ExecuteBackground(string args);
+
+        public abstract void Execute(FreeSWITCH.Native.Stream stream, FreeSWITCH.Native.Event evt, string args);
+    }
+}
@@ -0,0 +1,120 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * AppFunction.cs -- Base class for applications
+ *
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace FreeSWITCH
+{
+    public abstract class AppFunction
+    {
+        protected static bool Load() { return true; }
+
+        protected static void Unload() { }
+
+        void hangupCallback()
+        {
+            Log.WriteLine(LogLevel.Debug, "AppFunction is in hangupCallback.");
+            var f = HangupFunction;
+            if (f != null) f();
+        }
+
+        protected Action HangupFunction { get; set; }
+
+        protected Func<Char, TimeSpan, string> DtmfReceivedFunction { get; set; }
+
+        protected Func<Native.Event, string> EventReceivedFunction { get; set; }
+
+        string inputCallback(IntPtr input, Native.switch_input_type_t inputType)
+        {
+            switch (inputType) {
+                case FreeSWITCH.Native.switch_input_type_t.SWITCH_INPUT_TYPE_DTMF:
+                    using (var dtmf = new Native.switch_dtmf_t(input, false)) {
+                        return dtmfCallback(dtmf);
+                    }
+                case FreeSWITCH.Native.switch_input_type_t.SWITCH_INPUT_TYPE_EVENT:
+                    using (var swevt = new Native.switch_event(input, false)) {
+                        return eventCallback(swevt);
+                    }
+                default: 
+                    return "";
+            }
+        }
+
+        string dtmfCallback(Native.switch_dtmf_t dtmf)
+        {
+            var f = DtmfReceivedFunction;
+            return f == null ?
+                "-ERR No DtmfReceivedFunction set." :
+                f(((char)(byte)dtmf.digit), TimeSpan.FromMilliseconds(dtmf.duration));
+        }
+
+        string eventCallback(Native.switch_event swevt)
+        {
+            using (var evt = new FreeSWITCH.Native.Event(swevt, 0)) {
+                var f = EventReceivedFunction;
+                return f == null ?
+                    "-ERR No EventReceivedFunction set." :
+                    f(evt);
+            }
+        }
+
+        protected Native.MonoSession Session { get; private set; }
+
+        protected string Arguments { get; private set; }
+
+        public bool IsAvailable
+        {
+            get
+            {
+                if (this.Session == null) return false;
+                return this.Session.Ready();
+            }
+        }
+
+        protected Guid Uuid { get; private set; }
+
+        internal void RunInternal(FreeSWITCH.Native.MonoSession session, string args)
+        {
+            this.Session = session;
+            this.Arguments = args;
+            Session.SetDelegates(this.inputCallback, this.hangupCallback);
+            try { this.Uuid = new Guid(Session.GetUuid()); }
+            catch { }
+            Run();
+        }
+
+        protected abstract void Run();
+    }
+}
@@ -0,0 +1,104 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * Demo.cs -- mod_mono demo classes
+ *
+ */
+
+#if DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Demo
+{
+    public class AppDemo : AppFunction
+    {
+        new protected static bool Load()
+        {
+            Log.WriteLine(LogLevel.Debug, "Inside AppDemo::Load.");
+            return true;
+        }
+
+        new protected static void Unload()
+        {
+            Log.WriteLine(LogLevel.Debug, "Inside AppDemo::Unload.");
+        }
+
+        protected override void Run()
+        {
+            HangupFunction = hangupHook;
+            Session.Answer();
+            this.DtmfReceivedFunction = (d, t) => {
+                Log.WriteLine(LogLevel.Info, "Received {0} for {1}.", d, t);
+                return "";
+            };
+            Log.WriteLine(LogLevel.Debug, "Inside AppDemo.Run (args '{0}'); HookState is {1}.", Arguments, Session.HookState);
+            Session.CollectDigits(5000);
+            if (!IsAvailable) return; // Hungup
+            Session.Hangup("USER_BUSY");
+        }
+        
+        void hangupHook()
+        {
+            Log.WriteLine(LogLevel.Debug, "AppDemo hanging up, UUID: {0}.", this.Uuid);
+        }
+    }
+
+    public class ApiDemo : ApiFunction
+    {
+        new protected static bool Load()
+        {
+            Log.WriteLine(LogLevel.Debug, "Inside ApiDemo::Load.");
+            return true;
+        }
+
+        new protected static void Unload()
+        {
+            Log.WriteLine(LogLevel.Debug, "Inside ApiDemo::Unload.");
+        }
+
+        public override void ExecuteBackground(string args)
+        {
+            Log.WriteLine(LogLevel.Debug, "ApiDemo on a background thread #({0}), with args '{1}'.",
+                System.Threading.Thread.CurrentThread.ManagedThreadId,
+                args);
+        }
+
+        public override void Execute(Native.Stream stream, Native.Event evt, string args)
+        {
+            stream.Write(string.Format("ApiDemo executed with args '{0}' and event type {1}.",
+                args, evt == null ? "<none>" : evt.GetEventType()));
+        }
+
+    }
+
+}
+
+#endif
@@ -0,0 +1,47 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * Extensions.cs -- Helper extensions
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace System.Linq
+{
+    internal static class EnumerableExtensions
+    {
+        public static void ForEach<T>(this IEnumerable<T> source, Action<T> f)
+        {
+            foreach (var item in source) {
+                f(item);
+            }
+        }
+    }
+}
@@ -0,0 +1,252 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * Loader.cs -- mod_mono managed loader
+ *
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace FreeSWITCH
+{
+    internal static class Loader
+    {
+        // Stores a list of the loaded function types so we can instantiate them as needed
+        static readonly Dictionary<string, Type> functions = new Dictionary<string, Type>(StringComparer.InvariantCultureIgnoreCase);
+
+        #region Load/Unload
+
+        public static bool Load()
+        {
+            string managedDir = Path.Combine(Native.freeswitch.SWITCH_GLOBAL_dirs.mod_dir, "mono");
+            Log.WriteLine(LogLevel.Debug, "mod_mono_managed loader is starting with directory '{0}'.", managedDir);
+            if (!Directory.Exists(managedDir)) {
+                Log.WriteLine(LogLevel.Error, "Managed directory not found: {0}", managedDir);
+                return false;
+            }
+
+            // This is a simple one-time loader to get things in memory
+            // Some day we should allow reloading of modules or something
+            loadAssemblies(managedDir)
+                .SelectMany(a => a.GetExportedTypes())
+                .Where(t => !t.IsAbstract)
+                .Where(t => t.IsSubclassOf(typeof(AppFunction)) || t.IsSubclassOf(typeof(ApiFunction)))
+                .ToList()
+                .loadFunctions();
+
+            return true;
+        }
+
+        // Be rather lenient in finding the Load and Unload methods
+        static readonly BindingFlags methodBindingFlags =
+            BindingFlags.Static | // Required
+            BindingFlags.Public | BindingFlags.NonPublic | // Implementors might decide to make the load method private
+            BindingFlags.IgnoreCase | // Some case insensitive languages?
+            BindingFlags.FlattenHierarchy; // Allow inherited methods for hierarchies
+
+        static void loadFunctions(this List<Type> allTypes)
+        {
+            foreach (var t in allTypes) {
+                try {
+                    if (functions.ContainsKey(t.FullName)) {
+                        Log.WriteLine(LogLevel.Error, "Duplicate function {0}. Skipping.", t.FullName);
+                        continue;
+                    }
+                    var loadMethod = t.GetMethod("Load", methodBindingFlags, null, Type.EmptyTypes, null);
+                    var shouldLoad = Convert.ToBoolean(loadMethod.Invoke(null, null)); // We don't require the Load method to return a bool exactly
+                    if (shouldLoad) {
+                        Log.WriteLine(LogLevel.Notice, "Function {0} loaded.", t.FullName);
+                        functions.Add(t.FullName, t);
+                    }
+                    else {
+                        Log.WriteLine(LogLevel.Notice, "Function {0} requested not to be loaded.", t.FullName);
+                    }
+                }
+                catch (Exception ex) {
+                    logException("Load", t.FullName, ex);
+                }
+            } 
+        }
+
+        static List<Assembly> loadAssemblies(string managedDir)
+        {
+            return Directory.GetFiles(managedDir, "*.dll", SearchOption.AllDirectories)
+                  .Select(f => Path.Combine(managedDir, f))
+                  .Select(f => {
+                      try {
+                          return System.Reflection.Assembly.LoadFile(f);
+                      }
+                      catch (Exception ex) {
+                          Log.WriteLine(LogLevel.Notice, "Assembly.LoadFile failed; skipping {0} ({1})", f, ex.Message);
+                          return null;
+                      }
+                  })
+                  .Where(a => a != null)
+                  .Concat(new[] { System.Reflection.Assembly.GetExecutingAssembly() }) // Add in our own to load Demo or built-in things if added
+                  .ToList();
+        }
+
+        public static void Unload()
+        {
+            Log.WriteLine(LogLevel.Debug, "mod_mono_managed Loader is unloading.");
+            foreach (var t in functions.Values) {
+                try {
+                    var unloadMethod = t.GetMethod("Unload", methodBindingFlags, null, Type.EmptyTypes, null);
+                    unloadMethod.Invoke(null, null);
+                }
+                catch (Exception ex) {
+                    logException("Unload", t.FullName, ex);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Execution
+
+        static Type getFunctionType<TFunction>(string fullName)
+        {
+            Type t;
+            if (!functions.TryGetValue(fullName, out t) || !t.IsSubclassOf(typeof(TFunction))) {
+                Log.WriteLine(LogLevel.Error, "Could not find function {0}.", fullName);
+                return null;
+            }
+            return t;
+        }
+
+        static readonly char[] spaceArray = new[] { ' ' };
+        /// <summary>Returns a string couple containing the module name and arguments</summary>
+        static string[] parseCommand(string command)
+        {
+            if (string.IsNullOrEmpty(command)) {
+                Log.WriteLine(LogLevel.Error, "No arguments supplied.");
+                return null;
+            }
+            var args = command.Split(spaceArray, 2, StringSplitOptions.RemoveEmptyEntries);
+            if (args.Length == 0 || string.IsNullOrEmpty(args[0]) || string.IsNullOrEmpty(args[0].Trim())) {
+                Log.WriteLine(LogLevel.Error, "Module name not supplied.");
+                return null;
+            }
+            if (args.Length == 1) {
+                return new[] { args[0], "" };
+            }
+            else {
+                return args;
+            }
+        }
+
+        public static bool ExecuteBackground(string command)
+        {
+            var parsed = parseCommand(command);
+            if (parsed == null) return false;
+            var fullName = parsed[0];
+            var args = parsed[1];
+
+            var fType = getFunctionType<ApiFunction>(fullName);
+            if (fType == null) return false;
+
+            new System.Threading.Thread(() => {
+                try {
+                    var f = (ApiFunction)Activator.CreateInstance(fType);
+                    f.ExecuteBackground(args);
+                    Log.WriteLine(LogLevel.Debug, "ExecuteBackground in {0} completed.", fullName);
+                }
+                catch (Exception ex) {
+                    logException("ExecuteBackground", fullName, ex);
+                }
+            }).Start();
+            return true;
+        }
+
+        public static bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle)
+        {
+            System.Diagnostics.Debug.Assert(streamHandle != IntPtr.Zero, "streamHandle is null.");
+            var parsed = parseCommand(command);
+            if (parsed == null) return false;
+            var fullName = parsed[0];
+            var args = parsed[1];
+            
+            var fType = getFunctionType<ApiFunction>(fullName);
+            if (fType == null) return false;
+
+            using (var stream = new Native.Stream(new Native.switch_stream_handle(streamHandle, false)))
+            using (var evt = eventHandle == IntPtr.Zero ? null : new Native.Event(new Native.switch_event(eventHandle, false), 0)) {
+                
+                try {
+                    var f = (ApiFunction)Activator.CreateInstance(fType);
+                    f.Execute(stream, evt, args);
+                    return true;
+                }
+                catch (Exception ex) {
+                    logException("Execute", fullName, ex);
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>Runs an application function.</summary>
+        public static bool Run(string command, IntPtr sessionHandle)
+        {
+            Log.WriteLine(LogLevel.Debug, "mod_mono attempting to run application '{0}'.", command);
+            System.Diagnostics.Debug.Assert(sessionHandle != IntPtr.Zero, "sessionHandle is null.");
+            var parsed = parseCommand(command);
+            if (parsed == null) return false;
+            var fullName = parsed[0];
+            var args = parsed[1];
+
+            var fType = getFunctionType<AppFunction>(fullName);
+            if (fType == null) return false;
+
+            using (var session = new Native.MonoSession(new Native.SWIGTYPE_p_switch_core_session(sessionHandle, false))) {
+                try {
+                    var f = (AppFunction)Activator.CreateInstance(fType);
+                    f.RunInternal(session, args);
+                    return true;
+                }
+                catch (Exception ex) {
+                    logException("Run", fullName, ex);
+                    return false;
+                }
+            }
+        }
+
+        static void logException(string action, string moduleName, Exception ex)
+        {
+            Log.WriteLine(LogLevel.Error, "{0} exception in {1}: {2}", action, moduleName, ex.Message);
+            Log.WriteLine(LogLevel.Debug, "{0} exception: {1}", moduleName, ex.ToString());
+        }
+
+        #endregion
+    }
+
+}
+ 
@@ -0,0 +1,96 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * Log.cs -- Log wrappers
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH
+{
+    public static class Log
+    {
+        public static void Write(LogLevel level, string message)
+        {
+            Native.freeswitch.console_log(level.ToLogString(), message);
+        }
+        public static void Write(LogLevel level, string format, params object[] args)
+        {
+            Native.freeswitch.console_log(level.ToLogString(), string.Format(format, args));
+        }
+        public static void WriteLine(LogLevel level, string message)
+        {
+            Native.freeswitch.console_log(level.ToLogString(), message + Environment.NewLine);
+        }
+        public static void WriteLine(LogLevel level, string format, params object[] args)
+        {
+            Native.freeswitch.console_log(level.ToLogString(), string.Format(format, args) + Environment.NewLine);
+        }
+
+        static string ToLogString(this LogLevel level)
+        {
+            switch (level) {
+                case LogLevel.Alert: return "ALERT";
+                case LogLevel.Critical: return "CRIT";
+                case LogLevel.Debug: return "DEBUG";
+                case LogLevel.Error: return "ERR";
+                case LogLevel.Info: return "INFO";
+                case LogLevel.Notice: return "NOTICE";
+                case LogLevel.Warning: return "WARNING";
+                default: 
+                    System.Diagnostics.Debug.Fail("Invalid LogLevel: " + level.ToString() + " (" + (int)level+ ").");
+                    return "INFO";
+            }
+        }
+    }
+
+    /*switch_log.c:
+    tatic const char *LEVELS[] = {
+	"CONSOLE",
+	"ALERT",
+	"CRIT",
+	"ERR",
+	"WARNING",
+	"NOTICE",
+	"INFO",
+	"DEBUG",
+	NULL
+    };*/
+    public enum LogLevel
+    {
+        Debug,
+        Info,
+        Error,
+        Critical,
+        Alert,
+        Warning,
+        Notice,
+    }
+}
@@ -0,0 +1,52 @@
+/* 
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@packetrino.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_mono
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Michael Giagnocavo <mgg@packetrino.com>
+ * 
+ * MonoSession.cs -- MonoSession additional functions
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Native
+{
+    //switch_status_t MonoSession::run_dtmf_callback(void *input, switch_input_type_t itype)
+    // But, process_callback_result is used to turn a string into a switch_status_t
+    using DtmfCallback = Func<IntPtr, Native.switch_input_type_t, string>;
+    public partial class MonoSession
+    {
+        // SWITCH_DECLARE(void) InitMonoSession(MonoSession *session, MonoObject *dtmfDelegate, MonoObject *hangupDelegate)
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]
+        static extern void InitMonoSession(IntPtr sessionPtr, DtmfCallback dtmfDelegate, Action hangupDelegate);
+
+        internal void SetDelegates(DtmfCallback dtmfCallback, Action hangupHook)
+        {
+            InitMonoSession(MonoSession.getCPtr(this).Handle, dtmfCallback, hangupHook);
+        }
+    }
+}
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("mod_mono_managed")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("mod_mono_managed")]
+[assembly: AssemblyCopyright("Copyright ©  2008")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("b66ea632-ec95-4c9e-9cf7-7c0805a50526")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
@@ -0,0 +1,331 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{834E2B2F-5483-4B80-8FE3-FE48FF76E5C0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>mod_mono_managed</RootNamespace>
+    <AssemblyName>mod_mono_managed</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <StartupObject>
+    </StartupObject>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\Debug\mod\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="MonoSession.cs" />
+    <Compile Include="Loader.cs" />
+    <Compile Include="Extensions.cs" />
+    <Compile Include="Log.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ApiFunction.cs" />
+    <Compile Include="AppFunction.cs" />
+    <Compile Include="Demo.cs" />
+    <Compile Include="swig\API.cs" />
+    <Compile Include="swig\CoreSession.cs" />
+    <Compile Include="swig\Event.cs" />
+    <Compile Include="swig\freeswitch.cs" />
+    <Compile Include="swig\freeswitchPINVOKE_fixed.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="swig\input_callback_state_t.cs" />
+    <Compile Include="swig\IVRMenu.cs" />
+    <Compile Include="swig\MonoSession.cs" />
+    <Compile Include="swig\session_flag_t.cs" />
+    <Compile Include="swig\Stream.cs" />
+    <Compile Include="swig\SWIGTYPE_p_apr_pool_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_FILE.cs" />
+    <Compile Include="swig\SWIGTYPE_p_float.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_char_enum_switch_management_action_t_p_char_switch_size_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_char_p_char_p_char_p_char_p_char_p_char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_p_switch_loadable_module_interface_p_apr_pool_t__switch_status_t.cs" />
+    <Compile Include="swig\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.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_q_const__char_p_switch_core_session_p_switch_stream_handle__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_asr_handle_p_enum_switch_asr_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_asr_handle_p_p_char_p_enum_switch_asr_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_int_p_q_const__char_p_enum_switch_asr_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_p_q_const__char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_asr_handle_p_void_unsigned_int_p_enum_switch_asr_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_asr_handle__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_codec_enum_switch_codec_flag_t_p_q_const__switch_codec_settings__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_codec_p_switch_codec_p_void_unsigned_long_unsigned_long_p_void_p_unsigned_long_p_unsigned_long_p_unsigned_int__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_codec__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_char_enum_switch_say_type_t_enum_switch_say_method_t_p_switch_input_args_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_q_const__char__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_p_switch_core_session_p_p_apr_pool_t_enum_switch_originate_flag_t__switch_call_cause_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_enum_switch_originate_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_p_void__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_p_void_enum_switch_input_type_t_p_void_unsigned_int__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session_t_p_void_p_switch_caller_profile_t__p_switch_caller_extension.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_core_session__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char_p_char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_directory_handle_p_p_char_p_p_char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_directory_handle__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_event__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_p_q_const__char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_q_const__char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_file_handle_p_q_const__char__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_file_handle_p_unsigned_int_long_long_int__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_file_handle_p_void_p_switch_size_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_file_handle__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_rtp_p_switch_socket_t_p_void_switch_size_t_p_switch_sockaddr_t__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_scheduler_task__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle_p_char_double__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle_p_char_int__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_enum_switch_speech_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_q_const__char__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle_p_enum_switch_speech_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle_p_q_const__char_int_p_enum_switch_speech_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle_p_void_p_switch_size_t_p_unsigned_long_p_enum_switch_speech_flag_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_speech_handle__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_stream_handle_p_q_const__char_v_______switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_stream_handle_p_unsigned_char_switch_size_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_timer_enum_switch_bool_t__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_switch_timer__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_void_int_p_p_char_p_p_char__int.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_p_void__void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_f_void__switch_status_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_HashElem.cs" />
+    <Compile Include="swig\SWIGTYPE_p_int.cs" />
+    <Compile Include="swig\SWIGTYPE_p_in_addr.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_apr_pool_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_char.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_p_char.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_real_pcre.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_sqlite3.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_sqlite3_stmt.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_audio_resampler_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_buffer.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_channel.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_core_port_allocator.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_core_session.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_core_session_message.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_event.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_frame.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_hash.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_ivr_digit_stream.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_ivr_digit_stream_parser.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_ivr_menu.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_ivr_menu_xml_ctx.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_media_bug.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_network_list.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_rtp.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_switch_xml.cs" />
+    <Compile Include="swig\SWIGTYPE_p_p_void.cs" />
+    <Compile Include="swig\SWIGTYPE_p_real_pcre.cs" />
+    <Compile Include="swig\SWIGTYPE_p_short.cs" />
+    <Compile Include="swig\SWIGTYPE_p_sqlite3.cs" />
+    <Compile Include="swig\SWIGTYPE_p_sqlite3_stmt.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_asr_flag_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_buffer.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_call_cause_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_channel.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_core_port_allocator.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_core_session.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_event_types_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_file_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_frame_flag_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_hash.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_ivr_action_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_ivr_digit_stream.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_ivr_digit_stream_parser.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_ivr_menu.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_ivr_menu_action_function_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_ivr_menu_xml_ctx.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_loadable_module_interface.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_media_bug.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_mutex_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_network_list.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_pollfd_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_rtp.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_size_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_sockaddr_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_socket_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_speech_flag_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_ssize_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_switch_time_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_time_t.cs" />
+    <Compile Include="swig\SWIGTYPE_p_unsigned_char.cs" />
+    <Compile Include="swig\SWIGTYPE_p_unsigned_int.cs" />
+    <Compile Include="swig\SWIGTYPE_p_unsigned_long.cs" />
+    <Compile Include="swig\SWIGTYPE_p_unsigned_short.cs" />
+    <Compile Include="swig\SWIGTYPE_p_void.cs" />
+    <Compile Include="swig\switch_abc_type_t.cs" />
+    <Compile Include="swig\switch_api_interface.cs" />
+    <Compile Include="swig\switch_application_flag_t.cs" />
+    <Compile Include="swig\switch_application_interface.cs" />
+    <Compile Include="swig\switch_app_log.cs" />
+    <Compile Include="swig\switch_asr_flag_t.cs" />
+    <Compile Include="swig\switch_asr_handle.cs" />
+    <Compile Include="swig\switch_asr_interface.cs" />
+    <Compile Include="swig\switch_audio_col_t.cs" />
+    <Compile Include="swig\switch_audio_resampler_t.cs" />
+    <Compile Include="swig\switch_bind_flag_t.cs" />
+    <Compile Include="swig\switch_bitpack_mode_t.cs" />
+    <Compile Include="swig\switch_bitpack_t.cs" />
+    <Compile Include="swig\switch_bool_t.cs" />
+    <Compile Include="swig\switch_caller_application.cs" />
+    <Compile Include="swig\switch_caller_extension.cs" />
+    <Compile Include="swig\switch_caller_profile.cs" />
+    <Compile Include="swig\switch_caller_profile_flag_t.cs" />
+    <Compile Include="swig\switch_call_cause_t.cs" />
+    <Compile Include="swig\switch_channel_flag_t.cs" />
+    <Compile Include="swig\switch_channel_state_t.cs" />
+    <Compile Include="swig\switch_channel_timetable.cs" />
+    <Compile Include="swig\switch_chat_interface.cs" />
+    <Compile Include="swig\switch_codec.cs" />
+    <Compile Include="swig\switch_codec_flag_t.cs" />
+    <Compile Include="swig\switch_codec_implementation.cs" />
+    <Compile Include="swig\switch_codec_interface.cs" />
+    <Compile Include="swig\switch_codec_settings.cs" />
+    <Compile Include="swig\switch_codec_type_t.cs" />
+    <Compile Include="swig\switch_config.cs" />
+    <Compile Include="swig\switch_core_flag_t.cs" />
+    <Compile Include="swig\switch_core_session_message.cs" />
+    <Compile Include="swig\switch_core_session_message_flag_t.cs" />
+    <Compile Include="swig\switch_core_session_message_types_t.cs" />
+    <Compile Include="swig\switch_core_thread_session.cs" />
+    <Compile Include="swig\switch_core_time_duration.cs" />
+    <Compile Include="swig\switch_dialplan_interface.cs" />
+    <Compile Include="swig\switch_directories.cs" />
+    <Compile Include="swig\switch_directory_flag_t.cs" />
+    <Compile Include="swig\switch_directory_handle.cs" />
+    <Compile Include="swig\switch_directory_interface.cs" />
+    <Compile Include="swig\switch_dtmf_direction_t.cs" />
+    <Compile Include="swig\switch_dtmf_t.cs" />
+    <Compile Include="swig\switch_eavesdrop_flag_t.cs" />
+    <Compile Include="swig\switch_endpoint_interface.cs" />
+    <Compile Include="swig\switch_event.cs" />
+    <Compile Include="swig\switch_event_header.cs" />
+    <Compile Include="swig\switch_event_node.cs" />
+    <Compile Include="swig\switch_event_subclass.cs" />
+    <Compile Include="swig\switch_event_types_t.cs" />
+    <Compile Include="swig\switch_file_flag_t.cs" />
+    <Compile Include="swig\switch_file_handle.cs" />
+    <Compile Include="swig\switch_file_interface.cs" />
+    <Compile Include="swig\switch_frame.cs" />
+    <Compile Include="swig\switch_frame_flag_t.cs" />
+    <Compile Include="swig\switch_input_args_t.cs" />
+    <Compile Include="swig\switch_input_type_t.cs" />
+    <Compile Include="swig\switch_io_event_hooks.cs" />
+    <Compile Include="swig\switch_io_event_hook_kill_channel.cs" />
+    <Compile Include="swig\switch_io_event_hook_outgoing_channel.cs" />
+    <Compile Include="swig\switch_io_event_hook_read_frame.cs" />
+    <Compile Include="swig\switch_io_event_hook_receive_event.cs" />
+    <Compile Include="swig\switch_io_event_hook_receive_message.cs" />
+    <Compile Include="swig\switch_io_event_hook_recv_dtmf.cs" />
+    <Compile Include="swig\switch_io_event_hook_resurrect_session.cs" />
+    <Compile Include="swig\switch_io_event_hook_send_dtmf.cs" />
+    <Compile Include="swig\switch_io_event_hook_state_change.cs" />
+    <Compile Include="swig\switch_io_event_hook_video_read_frame.cs" />
+    <Compile Include="swig\switch_io_event_hook_video_write_frame.cs" />
+    <Compile Include="swig\switch_io_event_hook_write_frame.cs" />
+    <Compile Include="swig\switch_io_flag_t.cs" />
+    <Compile Include="swig\switch_io_routines.cs" />
+    <Compile Include="swig\switch_io_routine_name_t.cs" />
+    <Compile Include="swig\switch_ivr_action_t.cs" />
+    <Compile Include="swig\switch_ivr_menu_flags.cs" />
+    <Compile Include="swig\switch_ivr_option_t.cs" />
+    <Compile Include="swig\switch_loadable_module_function_table_t.cs" />
+    <Compile Include="swig\switch_log_level_t.cs" />
+    <Compile Include="swig\switch_log_node_t.cs" />
+    <Compile Include="swig\switch_management_action_t.cs" />
+    <Compile Include="swig\switch_management_interface.cs" />
+    <Compile Include="swig\switch_media_bug_flag_t.cs" />
+    <Compile Include="swig\switch_media_flag_t.cs" />
+    <Compile Include="swig\switch_module_interface_name_t.cs" />
+    <Compile Include="swig\switch_originate_flag_t.cs" />
+    <Compile Include="swig\switch_port_flag_t.cs" />
+    <Compile Include="swig\switch_priority_t.cs" />
+    <Compile Include="swig\switch_rtp_crypto_direction_t.cs" />
+    <Compile Include="swig\switch_rtp_crypto_key.cs" />
+    <Compile Include="swig\switch_rtp_crypto_key_type_t.cs" />
+    <Compile Include="swig\switch_rtp_flag_t.cs" />
+    <Compile Include="swig\switch_rtp_hdr_t.cs" />
+    <Compile Include="swig\switch_say_interface.cs" />
+    <Compile Include="swig\switch_say_method_t.cs" />
+    <Compile Include="swig\switch_say_type_t.cs" />
+    <Compile Include="swig\switch_scheduler_flag_t.cs" />
+    <Compile Include="swig\switch_scheduler_task.cs" />
+    <Compile Include="swig\switch_session_ctl_t.cs" />
+    <Compile Include="swig\switch_signal_t.cs" />
+    <Compile Include="swig\switch_speech_flag_t.cs" />
+    <Compile Include="swig\switch_speech_handle.cs" />
+    <Compile Include="swig\switch_speech_interface.cs" />
+    <Compile Include="swig\switch_stack_t.cs" />
+    <Compile Include="swig\switch_state_handler_name_t.cs" />
+    <Compile Include="swig\switch_state_handler_table.cs" />
+    <Compile Include="swig\switch_status_t.cs" />
+    <Compile Include="swig\switch_stream_handle.cs" />
+    <Compile Include="swig\switch_text_channel_t.cs" />
+    <Compile Include="swig\switch_timer.cs" />
+    <Compile Include="swig\switch_timer_flag_t.cs" />
+    <Compile Include="swig\switch_timer_func_name_t.cs" />
+    <Compile Include="swig\switch_timer_interface.cs" />
+    <Compile Include="swig\switch_unicast_conninfo.cs" />
+    <Compile Include="swig\switch_unicast_flag_t.cs" />
+    <Compile Include="swig\switch_vad_flag_t.cs" />
+    <Compile Include="swig\switch_xml.cs" />
+    <Compile Include="swig\switch_xml_flag_t.cs" />
+    <Compile Include="swig\switch_xml_section_t.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
@@ -0,0 +1,57 @@
+/* ----------------------------------------------------------------------------
+ * 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 Api : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal Api(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(Api obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~Api() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_Api(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public Api() : this(freeswitchPINVOKE.new_Api(), true) {
+  }
+
+  public string Execute(string command, string data) {
+    string ret = freeswitchPINVOKE.Api_Execute(swigCPtr, command, data);
+    return ret;
+  }
+
+  public string ExecuteString(string command) {
+    string ret = freeswitchPINVOKE.Api_ExecuteString(swigCPtr, command);
+    return ret;
+  }
+
+}
+
+}
@@ -0,0 +1,262 @@
+/* ----------------------------------------------------------------------------
+ * 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 CoreSession : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal CoreSession(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(CoreSession obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~CoreSession() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_CoreSession(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public SWIGTYPE_p_switch_core_session InternalSession {
+    set {
+      freeswitchPINVOKE.CoreSession_InternalSession_set(swigCPtr, SWIGTYPE_p_switch_core_session.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.CoreSession_InternalSession_get(swigCPtr);
+      SWIGTYPE_p_switch_core_session ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_core_session(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public SWIGTYPE_p_switch_channel channel {
+    set {
+      freeswitchPINVOKE.CoreSession_channel_set(swigCPtr, SWIGTYPE_p_switch_channel.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.CoreSession_channel_get(swigCPtr);
+      SWIGTYPE_p_switch_channel ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_channel(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public uint flags {
+    set {
+      freeswitchPINVOKE.CoreSession_flags_set(swigCPtr, value);
+    } 
+    get {
+      uint ret = freeswitchPINVOKE.CoreSession_flags_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public int allocated {
+    set {
+      freeswitchPINVOKE.CoreSession_allocated_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.CoreSession_allocated_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public input_callback_state_t cb_state {
+    set {
+      freeswitchPINVOKE.CoreSession_cb_state_set(swigCPtr, input_callback_state_t.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.CoreSession_cb_state_get(swigCPtr);
+      input_callback_state_t ret = (cPtr == IntPtr.Zero) ? null : new input_callback_state_t(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public switch_channel_state_t HookState {
+    set {
+      freeswitchPINVOKE.CoreSession_HookState_set(swigCPtr, (int)value);
+    } 
+    get {
+      switch_channel_state_t ret = (switch_channel_state_t)freeswitchPINVOKE.CoreSession_HookState_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public int Answer() {
+    int ret = freeswitchPINVOKE.CoreSession_Answer(swigCPtr);
+    return ret;
+  }
+
+  public int preAnswer() {
+    int ret = freeswitchPINVOKE.CoreSession_preAnswer(swigCPtr);
+    return ret;
+  }
+
+  public void Hangup(string cause) {
+    freeswitchPINVOKE.CoreSession_Hangup(swigCPtr, cause);
+  }
+
+  public void SetVariable(string var, string val) {
+    freeswitchPINVOKE.CoreSession_SetVariable(swigCPtr, var, val);
+  }
+
+  public void SetPrivate(string var, SWIGTYPE_p_void val) {
+    freeswitchPINVOKE.CoreSession_SetPrivate(swigCPtr, var, SWIGTYPE_p_void.getCPtr(val));
+  }
+
+  public SWIGTYPE_p_void GetPrivate(string var) {
+    IntPtr cPtr = freeswitchPINVOKE.CoreSession_GetPrivate(swigCPtr, var);
+    SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false);
+    return ret;
+  }
+
+  public string GetVariable(string var) {
+    string ret = freeswitchPINVOKE.CoreSession_GetVariable(swigCPtr, var);
+    return ret;
+  }
+
+  public void Say(string tosay, string module_name, string say_type, string say_method) {
+    freeswitchPINVOKE.CoreSession_Say(swigCPtr, tosay, module_name, say_type, say_method);
+  }
+
+  public void SayPhrase(string phrase_name, string phrase_data, string phrase_lang) {
+    freeswitchPINVOKE.CoreSession_SayPhrase(swigCPtr, phrase_name, phrase_data, phrase_lang);
+  }
+
+  public int RecordFile(string file_name, int max_len, int silence_threshold, int silence_secs) {
+    int ret = freeswitchPINVOKE.CoreSession_RecordFile(swigCPtr, file_name, max_len, silence_threshold, silence_secs);
+    return ret;
+  }
+
+  public void SetCallerData(string var, string val) {
+    freeswitchPINVOKE.CoreSession_SetCallerData(swigCPtr, var, val);
+  }
+
+  public int Originate(CoreSession a_leg_session, string dest, int timeout) {
+    int ret = freeswitchPINVOKE.CoreSession_Originate(swigCPtr, CoreSession.getCPtr(a_leg_session), dest, timeout);
+    return ret;
+  }
+
+  public int speak(string text) {
+    int ret = freeswitchPINVOKE.CoreSession_speak(swigCPtr, text);
+    return ret;
+  }
+
+  public void set_tts_parms(string tts_name, string voice_name) {
+    freeswitchPINVOKE.CoreSession_set_tts_parms(swigCPtr, tts_name, voice_name);
+  }
+
+  public int CollectDigits(int timeout) {
+    int ret = freeswitchPINVOKE.CoreSession_CollectDigits(swigCPtr, timeout);
+    return ret;
+  }
+
+  public string GetDigits(int maxdigits, string terminators, int timeout) {
+    string ret = freeswitchPINVOKE.CoreSession_GetDigits(swigCPtr, maxdigits, terminators, timeout);
+    return ret;
+  }
+
+  public int Transfer(string extensions, string dialplan, string context) {
+    int ret = freeswitchPINVOKE.CoreSession_Transfer(swigCPtr, extensions, dialplan, context);
+    return ret;
+  }
+
+  public string read(int min_digits, int max_digits, string prompt_audio_file, int timeout, string valid_terminators) {
+    string ret = freeswitchPINVOKE.CoreSession_read(swigCPtr, min_digits, max_digits, prompt_audio_file, timeout, valid_terminators);
+    return ret;
+  }
+
+  public string PlayAndGetDigits(int min_digits, int max_digits, int max_tries, int timeout, string terminators, string audio_files, string bad_input_audio_files, string digits_regex) {
+    string ret = freeswitchPINVOKE.CoreSession_PlayAndGetDigits(swigCPtr, min_digits, max_digits, max_tries, timeout, terminators, audio_files, bad_input_audio_files, digits_regex);
+    return ret;
+  }
+
+  public int StreamFile(string file, int starting_sample_count) {
+    int ret = freeswitchPINVOKE.CoreSession_StreamFile(swigCPtr, file, starting_sample_count);
+    return ret;
+  }
+
+  public int flushEvents() {
+    int ret = freeswitchPINVOKE.CoreSession_flushEvents(swigCPtr);
+    return ret;
+  }
+
+  public int flushDigits() {
+    int ret = freeswitchPINVOKE.CoreSession_flushDigits(swigCPtr);
+    return ret;
+  }
+
+  public int setAutoHangup(bool val) {
+    int ret = freeswitchPINVOKE.CoreSession_setAutoHangup(swigCPtr, val);
+    return ret;
+  }
+
+  public bool Ready() {
+    bool ret = freeswitchPINVOKE.CoreSession_Ready(swigCPtr);
+    return ret;
+  }
+
+  public void Execute(string app, string data) {
+    freeswitchPINVOKE.CoreSession_Execute(swigCPtr, app, data);
+  }
+
+  public void sendEvent(Event sendME) {
+    freeswitchPINVOKE.CoreSession_sendEvent(swigCPtr, Event.getCPtr(sendME));
+  }
+
+  public void setEventData(Event e) {
+    freeswitchPINVOKE.CoreSession_setEventData(swigCPtr, Event.getCPtr(e));
+  }
+
+  public string getXMLCDR() {
+    string ret = freeswitchPINVOKE.CoreSession_getXMLCDR(swigCPtr);
+    return ret;
+  }
+
+  public virtual bool begin_allow_threads() {
+    bool ret = freeswitchPINVOKE.CoreSession_begin_allow_threads(swigCPtr);
+    return ret;
+  }
+
+  public virtual bool end_allow_threads() {
+    bool ret = freeswitchPINVOKE.CoreSession_end_allow_threads(swigCPtr);
+    return ret;
+  }
+
+  public string GetUuid() {
+    string ret = freeswitchPINVOKE.CoreSession_GetUuid(swigCPtr);
+    return ret;
+  }
+
+  public switch_input_args_t get_cb_args() {
+    switch_input_args_t ret = new switch_input_args_t(freeswitchPINVOKE.CoreSession_get_cb_args(swigCPtr), false);
+    return ret;
+  }
+
+  public virtual void check_hangup_hook() {
+    freeswitchPINVOKE.CoreSession_check_hangup_hook(swigCPtr);
+  }
+
+}
+
+}
@@ -0,0 +1,126 @@
+/* ----------------------------------------------------------------------------
+ * 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 partial class Event : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal Event(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(Event obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~Event() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_Event(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public switch_event InternalEvent {
+    set {
+      freeswitchPINVOKE.Event_InternalEvent_set(swigCPtr, switch_event.getCPtr(value));
+    } 
+    get {
+      IntPtr cPtr = freeswitchPINVOKE.Event_InternalEvent_get(swigCPtr);
+      switch_event ret = (cPtr == IntPtr.Zero) ? null : new switch_event(cPtr, false);
+      return ret;
+    } 
+  }
+
+  public string serialized_string {
+    set {
+      freeswitchPINVOKE.Event_serialized_string_set(swigCPtr, value);
+    } 
+    get {
+      string ret = freeswitchPINVOKE.Event_serialized_string_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public int mine {
+    set {
+      freeswitchPINVOKE.Event_mine_set(swigCPtr, value);
+    } 
+    get {
+      int ret = freeswitchPINVOKE.Event_mine_get(swigCPtr);
+      return ret;
+    } 
+  }
+
+  public Event(string type, string subclass_name) : this(freeswitchPINVOKE.new_Event__SWIG_0(type, subclass_name), true) {
+  }
+
+  public Event(switch_event wrap_me, int free_me) : this(freeswitchPINVOKE.new_Event__SWIG_1(switch_event.getCPtr(wrap_me), free_me), true) {
+  }
+
+  public string Serialize(string format) {
+    string ret = freeswitchPINVOKE.Event_Serialize(swigCPtr, format);
+    return ret;
+  }
+
+  public bool SetPriority(switch_priority_t priority) {
+    bool ret = freeswitchPINVOKE.Event_SetPriority(swigCPtr, (int)priority);
+    return ret;
+  }
+
+  public string GetHeader(string header_name) {
+    string ret = freeswitchPINVOKE.Event_GetHeader(swigCPtr, header_name);
+    return ret;
+  }
+
+  public string GetBody() {
+    string ret = freeswitchPINVOKE.Event_GetBody(swigCPtr);
+    return ret;
+  }
+
+  public string GetEventType() {
+    string ret = freeswitchPINVOKE.Event_GetEventType(swigCPtr);
+    return ret;
+  }
+
+  public bool AddBody(string value) {
+    bool ret = freeswitchPINVOKE.Event_AddBody(swigCPtr, value);
+    return ret;
+  }
+
+  public bool AddHeader(string header_name, string value) {
+    bool ret = freeswitchPINVOKE.Event_AddHeader(swigCPtr, header_name, value);
+    return ret;
+  }
+
+  public bool DeleteHeader(string header_name) {
+    bool ret = freeswitchPINVOKE.Event_DeleteHeader(swigCPtr, header_name);
+    return ret;
+  }
+
+  public bool Fire() {
+    bool ret = freeswitchPINVOKE.Event_Fire(swigCPtr);
+    return ret;
+  }
+
+}
+
+}
@@ -0,0 +1,55 @@
+/* ----------------------------------------------------------------------------
+ * 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 IvrMenu : IDisposable {
+  private HandleRef swigCPtr;
+  protected bool swigCMemOwn;
+
+  internal IvrMenu(IntPtr cPtr, bool cMemoryOwn) {
+    swigCMemOwn = cMemoryOwn;
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(IvrMenu obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~IvrMenu() {
+    Dispose();
+  }
+
+  public virtual void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_IvrMenu(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public IvrMenu(IvrMenu 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) : this(freeswitchPINVOKE.new_IvrMenu(IvrMenu.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), true) {
+  }
+
+  public void bindAction(string action, string arg, string bind) {
+    freeswitchPINVOKE.IvrMenu_bindAction(swigCPtr, action, arg, bind);
+  }
+
+  public void Execute(CoreSession session, string name) {
+    freeswitchPINVOKE.IvrMenu_Execute(swigCPtr, CoreSession.getCPtr(session), name);
+  }
+
+}
+
+}
@@ -0,0 +1,52 @@
+/* ----------------------------------------------------------------------------
+ * 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 partial class MonoSession : CoreSession {
+  private HandleRef swigCPtr;
+
+  internal MonoSession(IntPtr cPtr, bool cMemoryOwn) : base(freeswitchPINVOKE.MonoSessionUpcast(cPtr), cMemoryOwn) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  internal static HandleRef getCPtr(MonoSession obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+
+  ~MonoSession() {
+    Dispose();
+  }
+
+  public override void Dispose() {
+    lock(this) {
+      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+        swigCMemOwn = false;
+        freeswitchPINVOKE.delete_MonoSession(swigCPtr);
+      }
+      swigCPtr = new HandleRef(null, IntPtr.Zero);
+      GC.SuppressFinalize(this);
+      base.Dispose();
+    }
+  }
+
+  public MonoSession() : this(freeswitchPINVOKE.new_MonoSession__SWIG_0(), true) {
+  }
+
+  public MonoSession(string uuid) : this(freeswitchPINVOKE.new_MonoSession__SWIG_1(uuid), true) {
+  }
+
+  public MonoSession(SWIGTYPE_p_switch_core_session session) : this(freeswitchPINVOKE.new_MonoSession__SWIG_2(SWIGTYPE_p_switch_core_session.getCPtr(session)), true) {
+  }
+
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_FILE {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_FILE(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_FILE() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_FILE obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_HashElem {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_HashElem(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_HashElem() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_HashElem obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_apr_pool_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_apr_pool_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_apr_pool_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_apr_pool_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_char_enum_switch_management_action_t_p_char_switch_size_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_char_enum_switch_management_action_t_p_char_switch_size_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_char_enum_switch_management_action_t_p_char_switch_size_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_char_enum_switch_management_action_t_p_char_switch_size_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_char_p_char_p_char_p_char_p_char_p_char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_char_p_char_p_char_p_char_p_char_p_char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_char_p_char_p_char_p_char_p_char_p_char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_char_p_char_p_char_p_char_p_char_p_char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_p_switch_core_session_p_p_apr_pool_t_p_void__switch_call_cause_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_p_switch_loadable_module_interface_p_apr_pool_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_p_switch_loadable_module_interface_p_apr_pool_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_p_switch_loadable_module_interface_p_apr_pool_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_p_switch_loadable_module_interface_p_apr_pool_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char_p_switch_event_t_p_void__p_switch_xml {
+  private HandleRef swigCPtr;
+
+  internal 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(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected 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() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(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 obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_q_const__char_p_switch_core_session_p_switch_stream_handle__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_q_const__char_p_switch_core_session_p_switch_stream_handle__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_q_const__char_p_switch_core_session_p_switch_stream_handle__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_q_const__char_p_switch_core_session_p_switch_stream_handle__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_q_const__switch_log_node_t_enum_switch_log_level_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_asr_handle__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_asr_handle__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_asr_handle__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_asr_handle__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_asr_handle_p_enum_switch_asr_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_asr_handle_p_enum_switch_asr_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_asr_handle_p_enum_switch_asr_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_asr_handle_p_enum_switch_asr_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_asr_handle_p_p_char_p_enum_switch_asr_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_asr_handle_p_p_char_p_enum_switch_asr_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_asr_handle_p_p_char_p_enum_switch_asr_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_asr_handle_p_p_char_p_enum_switch_asr_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_int_p_q_const__char_p_enum_switch_asr_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_int_p_q_const__char_p_enum_switch_asr_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_int_p_q_const__char_p_enum_switch_asr_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_int_p_q_const__char_p_enum_switch_asr_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_p_q_const__char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_p_q_const__char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_p_q_const__char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_asr_handle_p_q_const__char_p_q_const__char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_asr_handle_p_void_unsigned_int_p_enum_switch_asr_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_asr_handle_p_void_unsigned_int_p_enum_switch_asr_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_asr_handle_p_void_unsigned_int_p_enum_switch_asr_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_asr_handle_p_void_unsigned_int_p_enum_switch_asr_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_codec__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_codec__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_codec__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_codec__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_codec_enum_switch_codec_flag_t_p_q_const__switch_codec_settings__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_codec_enum_switch_codec_flag_t_p_q_const__switch_codec_settings__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_codec_enum_switch_codec_flag_t_p_q_const__switch_codec_settings__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_codec_enum_switch_codec_flag_t_p_q_const__switch_codec_settings__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_codec_p_switch_codec_p_void_unsigned_long_unsigned_long_p_void_p_unsigned_long_p_unsigned_long_p_unsigned_int__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_codec_p_switch_codec_p_void_unsigned_long_unsigned_long_p_void_p_unsigned_long_p_unsigned_long_p_unsigned_int__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_codec_p_switch_codec_p_void_unsigned_long_unsigned_long_p_void_p_unsigned_long_p_unsigned_long_p_unsigned_int__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_codec_p_switch_codec_p_void_unsigned_long_unsigned_long_p_void_p_unsigned_long_p_unsigned_long_p_unsigned_int__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_int__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_char_enum_switch_say_type_t_enum_switch_say_method_t_p_switch_input_args_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_char_enum_switch_say_type_t_enum_switch_say_method_t_p_switch_input_args_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_char_enum_switch_say_type_t_enum_switch_say_method_t_p_switch_input_args_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_char_enum_switch_say_type_t_enum_switch_say_method_t_p_switch_input_args_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_q_const__char__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_q_const__char__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_q_const__char__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_q_const__char__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_q_const__switch_dtmf_t_enum_switch_dtmf_direction_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_switch_core_session_message__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_switch_event__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_p_switch_core_session_p_p_apr_pool_t_enum_switch_originate_flag_t__switch_call_cause_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_p_switch_core_session_p_p_apr_pool_t_enum_switch_originate_flag_t__switch_call_cause_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_p_switch_core_session_p_p_apr_pool_t_enum_switch_originate_flag_t__switch_call_cause_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_p_switch_core_session_p_p_apr_pool_t_enum_switch_originate_flag_t__switch_call_cause_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_enum_switch_originate_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_enum_switch_originate_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_enum_switch_originate_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_switch_event_p_switch_caller_profile_p_switch_core_session_enum_switch_originate_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_enum_switch_io_flag_t_int__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_p_void__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_p_void__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_p_void__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_switch_frame_p_void__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_p_void_enum_switch_input_type_t_p_void_unsigned_int__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_p_void_enum_switch_input_type_t_p_void_unsigned_int__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_p_void_enum_switch_input_type_t_p_void_unsigned_int__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_void_enum_switch_input_type_t_p_void_unsigned_int__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_core_session_t_p_void_p_switch_caller_profile_t__p_switch_caller_extension {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_core_session_t_p_void_p_switch_caller_profile_t__p_switch_caller_extension(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_core_session_t_p_void_p_switch_caller_profile_t__p_switch_caller_extension() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_t_p_void_p_switch_caller_profile_t__p_switch_caller_extension obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_directory_handle__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_directory_handle__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_directory_handle__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_directory_handle__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char_p_char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char_p_char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char_p_char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_directory_handle_p_char_p_char_p_char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_directory_handle_p_p_char_p_p_char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_directory_handle_p_p_char_p_p_char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_directory_handle_p_p_char_p_p_char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_directory_handle_p_p_char_p_p_char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_event__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_event__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_event__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_event__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_file_handle__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_file_handle__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_file_handle__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_file_handle__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_p_q_const__char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_p_q_const__char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_p_q_const__char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_p_q_const__char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_q_const__char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_q_const__char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_q_const__char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_file_handle_enum_switch_audio_col_t_p_q_const__char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_file_handle_p_q_const__char__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_file_handle_p_q_const__char__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_file_handle_p_q_const__char__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_file_handle_p_q_const__char__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_file_handle_p_unsigned_int_long_long_int__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_file_handle_p_unsigned_int_long_long_int__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_file_handle_p_unsigned_int_long_long_int__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_file_handle_p_unsigned_int_long_long_int__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_file_handle_p_void_p_switch_size_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_file_handle_p_void_p_switch_size_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_file_handle_p_void_p_switch_size_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_file_handle_p_void_p_switch_size_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_rtp_p_switch_socket_t_p_void_switch_size_t_p_switch_sockaddr_t__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_rtp_p_switch_socket_t_p_void_switch_size_t_p_switch_sockaddr_t__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_rtp_p_switch_socket_t_p_void_switch_size_t_p_switch_sockaddr_t__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_rtp_p_switch_socket_t_p_void_switch_size_t_p_switch_sockaddr_t__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_scheduler_task__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_scheduler_task__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_scheduler_task__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_scheduler_task__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle_p_char_double__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle_p_char_double__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle_p_char_double__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle_p_char_double__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle_p_char_int__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle_p_char_int__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle_p_char_int__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle_p_char_int__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_enum_switch_speech_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_enum_switch_speech_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_enum_switch_speech_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_enum_switch_speech_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_q_const__char__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_q_const__char__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_q_const__char__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle_p_char_p_q_const__char__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle_p_enum_switch_speech_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle_p_enum_switch_speech_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle_p_enum_switch_speech_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle_p_enum_switch_speech_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle_p_q_const__char_int_p_enum_switch_speech_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle_p_q_const__char_int_p_enum_switch_speech_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle_p_q_const__char_int_p_enum_switch_speech_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle_p_q_const__char_int_p_enum_switch_speech_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_speech_handle_p_void_p_switch_size_t_p_unsigned_long_p_enum_switch_speech_flag_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_speech_handle_p_void_p_switch_size_t_p_unsigned_long_p_enum_switch_speech_flag_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_speech_handle_p_void_p_switch_size_t_p_unsigned_long_p_enum_switch_speech_flag_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_speech_handle_p_void_p_switch_size_t_p_unsigned_long_p_enum_switch_speech_flag_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_stream_handle_p_q_const__char_v_______switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_stream_handle_p_q_const__char_v_______switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_stream_handle_p_q_const__char_v_______switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_stream_handle_p_q_const__char_v_______switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_stream_handle_p_unsigned_char_switch_size_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_stream_handle_p_unsigned_char_switch_size_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_stream_handle_p_unsigned_char_switch_size_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_stream_handle_p_unsigned_char_switch_size_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_thread_t_p_void__p_void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_timer__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_timer__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_timer__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_timer__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_switch_timer_enum_switch_bool_t__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_switch_timer_enum_switch_bool_t__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_switch_timer_enum_switch_bool_t__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_timer_enum_switch_bool_t__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_void__void {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_void__void(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_void__void() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_void__void obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_p_void_int_p_p_char_p_p_char__int {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_p_void_int_p_p_char_p_p_char__int(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_p_void_int_p_p_char_p_p_char__int() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_p_void_int_p_p_char_p_p_char__int obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_f_void__switch_status_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_f_void__switch_status_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_f_void__switch_status_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_f_void__switch_status_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_float {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_float(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_float() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_float obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_in_addr {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_in_addr(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_in_addr() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_in_addr obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_int {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_int(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_int() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_int obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_apr_pool_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_apr_pool_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_apr_pool_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_apr_pool_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_char {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_char(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_char() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_char obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_p_char {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_p_char(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_p_char() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_p_char obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_real_pcre {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_real_pcre(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_real_pcre() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_real_pcre obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_sqlite3 {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_sqlite3(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_sqlite3() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_sqlite3 obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_sqlite3_stmt {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_sqlite3_stmt(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_sqlite3_stmt() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_sqlite3_stmt obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_switch_audio_resampler_t {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_switch_audio_resampler_t(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_switch_audio_resampler_t() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_switch_audio_resampler_t obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_switch_buffer {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_switch_buffer(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_switch_buffer() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_switch_buffer obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_switch_channel {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_switch_channel(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_switch_channel() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_switch_channel obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}
@@ -0,0 +1,30 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class SWIGTYPE_p_p_switch_core_port_allocator {
+  private HandleRef swigCPtr;
+
+  internal SWIGTYPE_p_p_switch_core_port_allocator(IntPtr cPtr, bool futureUse) {
+    swigCPtr = new HandleRef(this, cPtr);
+  }
+
+  protected SWIGTYPE_p_p_switch_core_port_allocator() {
+    swigCPtr = new HandleRef(null, IntPtr.Zero);
+  }
+
+  internal static HandleRef getCPtr(SWIGTYPE_p_p_switch_core_port_allocator obj) {
+    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+  }
+}
+
+}