// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

namespace Gst.RtspServer {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;

#region Autogenerated code
	public partial class RTSPClient : GLib.Object {

		public RTSPClient (IntPtr raw) : base(raw) {}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_new();

		public RTSPClient () : base (IntPtr.Zero)
		{
			if (GetType () != typeof (RTSPClient)) {
				CreateNativeObject (new string [0], new GLib.Value[0]);
				return;
			}
			Raw = gst_rtsp_client_new();
		}

		[GLib.Property ("drop-backlog")]
		public bool DropBacklog {
			get {
				GLib.Value val = GetProperty ("drop-backlog");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("drop-backlog", val);
				val.Dispose ();
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_get_mount_points(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_set_mount_points(IntPtr raw, IntPtr mounts);

		[GLib.Property ("mount-points")]
		public Gst.RtspServer.RTSPMountPoints MountPoints {
			get  {
				IntPtr raw_ret = gst_rtsp_client_get_mount_points(Handle);
				Gst.RtspServer.RTSPMountPoints ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPMountPoints;
				return ret;
			}
			set  {
				gst_rtsp_client_set_mount_points(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[GLib.Property ("post-session-timeout")]
		public int PostSessionTimeout {
			get {
				GLib.Value val = GetProperty ("post-session-timeout");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("post-session-timeout", val);
				val.Dispose ();
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_get_session_pool(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_set_session_pool(IntPtr raw, IntPtr pool);

		[GLib.Property ("session-pool")]
		public Gst.RtspServer.RTSPSessionPool SessionPool {
			get  {
				IntPtr raw_ret = gst_rtsp_client_get_session_pool(Handle);
				Gst.RtspServer.RTSPSessionPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPSessionPool;
				return ret;
			}
			set  {
				gst_rtsp_client_set_session_pool(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[GLib.Signal("play-request")]
		public event Gst.RtspServer.PlayRequestHandler PlayRequest {
			add {
				this.AddSignalHandler ("play-request", value, typeof (Gst.RtspServer.PlayRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("play-request", value);
			}
		}

		[GLib.Signal("pre-setup-request")]
		public event Gst.RtspServer.PreSetupRequestHandler PreSetupRequest {
			add {
				this.AddSignalHandler ("pre-setup-request", value, typeof (Gst.RtspServer.PreSetupRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-setup-request", value);
			}
		}

		[GLib.Signal("pause-request")]
		public event Gst.RtspServer.PauseRequestHandler PauseRequest {
			add {
				this.AddSignalHandler ("pause-request", value, typeof (Gst.RtspServer.PauseRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pause-request", value);
			}
		}

		[GLib.Signal("describe-request")]
		public event Gst.RtspServer.DescribeRequestHandler DescribeRequest {
			add {
				this.AddSignalHandler ("describe-request", value, typeof (Gst.RtspServer.DescribeRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("describe-request", value);
			}
		}

		[GLib.Signal("teardown-request")]
		public event Gst.RtspServer.TeardownRequestHandler TeardownRequest {
			add {
				this.AddSignalHandler ("teardown-request", value, typeof (Gst.RtspServer.TeardownRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("teardown-request", value);
			}
		}

		[GLib.Signal("setup-request")]
		public event Gst.RtspServer.SetupRequestHandler SetupRequest {
			add {
				this.AddSignalHandler ("setup-request", value, typeof (Gst.RtspServer.SetupRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("setup-request", value);
			}
		}

		[GLib.Signal("pre-get-parameter-request")]
		public event Gst.RtspServer.PreGetParameterRequestHandler PreGetParameterRequest {
			add {
				this.AddSignalHandler ("pre-get-parameter-request", value, typeof (Gst.RtspServer.PreGetParameterRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-get-parameter-request", value);
			}
		}

		[GLib.Signal("pre-record-request")]
		public event Gst.RtspServer.PreRecordRequestHandler PreRecordRequest {
			add {
				this.AddSignalHandler ("pre-record-request", value, typeof (Gst.RtspServer.PreRecordRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-record-request", value);
			}
		}

		[GLib.Signal("new-session")]
		public event Gst.RtspServer.NewSessionHandler NewSession {
			add {
				this.AddSignalHandler ("new-session", value, typeof (Gst.RtspServer.NewSessionArgs));
			}
			remove {
				this.RemoveSignalHandler ("new-session", value);
			}
		}

		[GLib.Signal("handle-response")]
		public event Gst.RtspServer.HandleResponseHandler HandleResponse {
			add {
				this.AddSignalHandler ("handle-response", value, typeof (Gst.RtspServer.HandleResponseArgs));
			}
			remove {
				this.RemoveSignalHandler ("handle-response", value);
			}
		}

		[GLib.Signal("announce-request")]
		public event Gst.RtspServer.AnnounceRequestHandler AnnounceRequest {
			add {
				this.AddSignalHandler ("announce-request", value, typeof (Gst.RtspServer.AnnounceRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("announce-request", value);
			}
		}

		[GLib.Signal("pre-teardown-request")]
		public event Gst.RtspServer.PreTeardownRequestHandler PreTeardownRequest {
			add {
				this.AddSignalHandler ("pre-teardown-request", value, typeof (Gst.RtspServer.PreTeardownRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-teardown-request", value);
			}
		}

		[GLib.Signal("set-parameter-request")]
		public event Gst.RtspServer.SetParameterRequestHandler SetParameterRequest {
			add {
				this.AddSignalHandler ("set-parameter-request", value, typeof (Gst.RtspServer.SetParameterRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("set-parameter-request", value);
			}
		}

		[GLib.Signal("send-message")]
		public event Gst.RtspServer.SendMessageEventHandler SendMessageEvent {
			add {
				this.AddSignalHandler ("send-message", value, typeof (Gst.RtspServer.SendMessageEventArgs));
			}
			remove {
				this.RemoveSignalHandler ("send-message", value);
			}
		}

		[GLib.Signal("pre-closed")]
		public event System.EventHandler PreClosed {
			add {
				this.AddSignalHandler ("pre-closed", value);
			}
			remove {
				this.RemoveSignalHandler ("pre-closed", value);
			}
		}

		[GLib.Signal("pre-set-parameter-request")]
		public event Gst.RtspServer.PreSetParameterRequestHandler PreSetParameterRequest {
			add {
				this.AddSignalHandler ("pre-set-parameter-request", value, typeof (Gst.RtspServer.PreSetParameterRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-set-parameter-request", value);
			}
		}

		[GLib.Signal("pre-describe-request")]
		public event Gst.RtspServer.PreDescribeRequestHandler PreDescribeRequest {
			add {
				this.AddSignalHandler ("pre-describe-request", value, typeof (Gst.RtspServer.PreDescribeRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-describe-request", value);
			}
		}

		[GLib.Signal("pre-play-request")]
		public event Gst.RtspServer.PrePlayRequestHandler PrePlayRequest {
			add {
				this.AddSignalHandler ("pre-play-request", value, typeof (Gst.RtspServer.PrePlayRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-play-request", value);
			}
		}

		[GLib.Signal("pre-pause-request")]
		public event Gst.RtspServer.PrePauseRequestHandler PrePauseRequest {
			add {
				this.AddSignalHandler ("pre-pause-request", value, typeof (Gst.RtspServer.PrePauseRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-pause-request", value);
			}
		}

		[GLib.Signal("pre-announce-request")]
		public event Gst.RtspServer.PreAnnounceRequestHandler PreAnnounceRequest {
			add {
				this.AddSignalHandler ("pre-announce-request", value, typeof (Gst.RtspServer.PreAnnounceRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-announce-request", value);
			}
		}

		[GLib.Signal("get-parameter-request")]
		public event Gst.RtspServer.GetParameterRequestHandler GetParameterRequest {
			add {
				this.AddSignalHandler ("get-parameter-request", value, typeof (Gst.RtspServer.GetParameterRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("get-parameter-request", value);
			}
		}

		[GLib.Signal("record-request")]
		public event Gst.RtspServer.RecordRequestHandler RecordRequest {
			add {
				this.AddSignalHandler ("record-request", value, typeof (Gst.RtspServer.RecordRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("record-request", value);
			}
		}

		[GLib.Signal("closed")]
		public event System.EventHandler Closed {
			add {
				this.AddSignalHandler ("closed", value);
			}
			remove {
				this.RemoveSignalHandler ("closed", value);
			}
		}

		[GLib.Signal("pre-options-request")]
		public event Gst.RtspServer.PreOptionsRequestHandler PreOptionsRequest {
			add {
				this.AddSignalHandler ("pre-options-request", value, typeof (Gst.RtspServer.PreOptionsRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("pre-options-request", value);
			}
		}

		[GLib.Signal("options-request")]
		public event Gst.RtspServer.OptionsRequestHandler OptionsRequest {
			add {
				this.AddSignalHandler ("options-request", value, typeof (Gst.RtspServer.OptionsRequestArgs));
			}
			remove {
				this.RemoveSignalHandler ("options-request", value);
			}
		}

		static PreClosedNativeDelegate PreClosed_cb_delegate;
		static PreClosedNativeDelegate PreClosedVMCallback {
			get {
				if (PreClosed_cb_delegate == null)
					PreClosed_cb_delegate = new PreClosedNativeDelegate (PreClosed_cb);
				return PreClosed_cb_delegate;
			}
		}

		static void OverridePreClosed (GLib.GType gtype)
		{
			OverridePreClosed (gtype, PreClosedVMCallback);
		}

		static void OverridePreClosed (GLib.GType gtype, PreClosedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "pre-closed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PreClosedNativeDelegate (IntPtr inst);

		static void PreClosed_cb (IntPtr inst)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnPreClosed ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreClosed")]
		protected virtual void OnPreClosed ()
		{
			InternalPreClosed ();
		}

		private void InternalPreClosed ()
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
			GLib.Value[] vals = new GLib.Value [1];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static CreateSdpNativeDelegate CreateSdp_cb_delegate;
		static CreateSdpNativeDelegate CreateSdpVMCallback {
			get {
				if (CreateSdp_cb_delegate == null)
					CreateSdp_cb_delegate = new CreateSdpNativeDelegate (CreateSdp_cb);
				return CreateSdp_cb_delegate;
			}
		}

		static void OverrideCreateSdp (GLib.GType gtype)
		{
			OverrideCreateSdp (gtype, CreateSdpVMCallback);
		}

		static void OverrideCreateSdp (GLib.GType gtype, CreateSdpNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("create_sdp"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr CreateSdpNativeDelegate (IntPtr inst, IntPtr media);

		static IntPtr CreateSdp_cb (IntPtr inst, IntPtr media)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Sdp.SDPMessage __result;
				__result = __obj.OnCreateSdp (GLib.Object.GetObject(media) as Gst.RtspServer.RTSPMedia);
				return __result == null ? IntPtr.Zero : __result.OwnedCopy;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideCreateSdp")]
		protected virtual Gst.Sdp.SDPMessage OnCreateSdp (Gst.RtspServer.RTSPMedia media)
		{
			return InternalCreateSdp (media);
		}

		private Gst.Sdp.SDPMessage InternalCreateSdp (Gst.RtspServer.RTSPMedia media)
		{
			CreateSdpNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("create_sdp"));
				unmanaged = (CreateSdpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CreateSdpNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, media == null ? IntPtr.Zero : media.Handle);
			return __result == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (__result, typeof (Gst.Sdp.SDPMessage), true);
		}

		static ConfigureClientMediaNativeDelegate ConfigureClientMedia_cb_delegate;
		static ConfigureClientMediaNativeDelegate ConfigureClientMediaVMCallback {
			get {
				if (ConfigureClientMedia_cb_delegate == null)
					ConfigureClientMedia_cb_delegate = new ConfigureClientMediaNativeDelegate (ConfigureClientMedia_cb);
				return ConfigureClientMedia_cb_delegate;
			}
		}

		static void OverrideConfigureClientMedia (GLib.GType gtype)
		{
			OverrideConfigureClientMedia (gtype, ConfigureClientMediaVMCallback);
		}

		static void OverrideConfigureClientMedia (GLib.GType gtype, ConfigureClientMediaNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_media"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ConfigureClientMediaNativeDelegate (IntPtr inst, IntPtr media, IntPtr stream, IntPtr ctx);

		static bool ConfigureClientMedia_cb (IntPtr inst, IntPtr media, IntPtr stream, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				bool __result;
				__result = __obj.OnConfigureClientMedia (GLib.Object.GetObject(media) as Gst.RtspServer.RTSPMedia, GLib.Object.GetObject(stream) as Gst.RtspServer.RTSPStream, Gst.RtspServer.RTSPContext.New (ctx));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideConfigureClientMedia")]
		protected virtual bool OnConfigureClientMedia (Gst.RtspServer.RTSPMedia media, Gst.RtspServer.RTSPStream stream, Gst.RtspServer.RTSPContext ctx)
		{
			return InternalConfigureClientMedia (media, stream, ctx);
		}

		private bool InternalConfigureClientMedia (Gst.RtspServer.RTSPMedia media, Gst.RtspServer.RTSPStream stream, Gst.RtspServer.RTSPContext ctx)
		{
			ConfigureClientMediaNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_media"));
				unmanaged = (ConfigureClientMediaNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ConfigureClientMediaNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			bool __result = unmanaged (this.Handle, media == null ? IntPtr.Zero : media.Handle, stream == null ? IntPtr.Zero : stream.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return __result;
		}

		static ConfigureClientTransportNativeDelegate ConfigureClientTransport_cb_delegate;
		static ConfigureClientTransportNativeDelegate ConfigureClientTransportVMCallback {
			get {
				if (ConfigureClientTransport_cb_delegate == null)
					ConfigureClientTransport_cb_delegate = new ConfigureClientTransportNativeDelegate (ConfigureClientTransport_cb);
				return ConfigureClientTransport_cb_delegate;
			}
		}

		static void OverrideConfigureClientTransport (GLib.GType gtype)
		{
			OverrideConfigureClientTransport (gtype, ConfigureClientTransportVMCallback);
		}

		static void OverrideConfigureClientTransport (GLib.GType gtype, ConfigureClientTransportNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_transport"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ConfigureClientTransportNativeDelegate (IntPtr inst, IntPtr ctx, IntPtr ct);

		static bool ConfigureClientTransport_cb (IntPtr inst, IntPtr ctx, IntPtr ct)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				bool __result;
				__result = __obj.OnConfigureClientTransport (Gst.RtspServer.RTSPContext.New (ctx), Gst.Rtsp.RTSPTransport.New (ct));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideConfigureClientTransport")]
		protected virtual bool OnConfigureClientTransport (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPTransport ct)
		{
			return InternalConfigureClientTransport (ctx, ct);
		}

		private bool InternalConfigureClientTransport (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPTransport ct)
		{
			ConfigureClientTransportNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_transport"));
				unmanaged = (ConfigureClientTransportNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ConfigureClientTransportNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			IntPtr native_ct = GLib.Marshaller.StructureToPtrAlloc (ct);
			bool __result = unmanaged (this.Handle, native_ctx, native_ct);
			Marshal.FreeHGlobal (native_ctx);
			Marshal.FreeHGlobal (native_ct);
			return __result;
		}

		static ParamsSetNativeDelegate ParamsSet_cb_delegate;
		static ParamsSetNativeDelegate ParamsSetVMCallback {
			get {
				if (ParamsSet_cb_delegate == null)
					ParamsSet_cb_delegate = new ParamsSetNativeDelegate (ParamsSet_cb);
				return ParamsSet_cb_delegate;
			}
		}

		static void OverrideParamsSet (GLib.GType gtype)
		{
			OverrideParamsSet (gtype, ParamsSetVMCallback);
		}

		static void OverrideParamsSet (GLib.GType gtype, ParamsSetNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("params_set"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int ParamsSetNativeDelegate (IntPtr inst, IntPtr ctx);

		static int ParamsSet_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPResult __result;
				__result = __obj.OnParamsSet (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideParamsSet")]
		protected virtual Gst.Rtsp.RTSPResult OnParamsSet (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalParamsSet (ctx);
		}

		private Gst.Rtsp.RTSPResult InternalParamsSet (Gst.RtspServer.RTSPContext ctx)
		{
			ParamsSetNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("params_set"));
				unmanaged = (ParamsSetNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ParamsSetNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPResult) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPResult) __result;
		}

		static ParamsGetNativeDelegate ParamsGet_cb_delegate;
		static ParamsGetNativeDelegate ParamsGetVMCallback {
			get {
				if (ParamsGet_cb_delegate == null)
					ParamsGet_cb_delegate = new ParamsGetNativeDelegate (ParamsGet_cb);
				return ParamsGet_cb_delegate;
			}
		}

		static void OverrideParamsGet (GLib.GType gtype)
		{
			OverrideParamsGet (gtype, ParamsGetVMCallback);
		}

		static void OverrideParamsGet (GLib.GType gtype, ParamsGetNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("params_get"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int ParamsGetNativeDelegate (IntPtr inst, IntPtr ctx);

		static int ParamsGet_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPResult __result;
				__result = __obj.OnParamsGet (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideParamsGet")]
		protected virtual Gst.Rtsp.RTSPResult OnParamsGet (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalParamsGet (ctx);
		}

		private Gst.Rtsp.RTSPResult InternalParamsGet (Gst.RtspServer.RTSPContext ctx)
		{
			ParamsGetNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("params_get"));
				unmanaged = (ParamsGetNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ParamsGetNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPResult) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPResult) __result;
		}

		static MakePathFromUriNativeDelegate MakePathFromUri_cb_delegate;
		static MakePathFromUriNativeDelegate MakePathFromUriVMCallback {
			get {
				if (MakePathFromUri_cb_delegate == null)
					MakePathFromUri_cb_delegate = new MakePathFromUriNativeDelegate (MakePathFromUri_cb);
				return MakePathFromUri_cb_delegate;
			}
		}

		static void OverrideMakePathFromUri (GLib.GType gtype)
		{
			OverrideMakePathFromUri (gtype, MakePathFromUriVMCallback);
		}

		static void OverrideMakePathFromUri (GLib.GType gtype, MakePathFromUriNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("make_path_from_uri"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr MakePathFromUriNativeDelegate (IntPtr inst, IntPtr uri);

		static IntPtr MakePathFromUri_cb (IntPtr inst, IntPtr uri)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				string __result;
				__result = __obj.OnMakePathFromUri (Gst.Rtsp.RTSPUrl.New (uri));
				return GLib.Marshaller.StringToPtrGStrdup(__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideMakePathFromUri")]
		protected virtual string OnMakePathFromUri (Gst.Rtsp.RTSPUrl uri)
		{
			return InternalMakePathFromUri (uri);
		}

		private string InternalMakePathFromUri (Gst.Rtsp.RTSPUrl uri)
		{
			MakePathFromUriNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("make_path_from_uri"));
				unmanaged = (MakePathFromUriNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(MakePathFromUriNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr native_uri = GLib.Marshaller.StructureToPtrAlloc (uri);
			IntPtr __result = unmanaged (this.Handle, native_uri);
			Marshal.FreeHGlobal (native_uri);
			return GLib.Marshaller.PtrToStringGFree(__result);
		}

		static AdjustPlayModeNativeDelegate AdjustPlayMode_cb_delegate;
		static AdjustPlayModeNativeDelegate AdjustPlayModeVMCallback {
			get {
				if (AdjustPlayMode_cb_delegate == null)
					AdjustPlayMode_cb_delegate = new AdjustPlayModeNativeDelegate (AdjustPlayMode_cb);
				return AdjustPlayMode_cb_delegate;
			}
		}

		static void OverrideAdjustPlayMode (GLib.GType gtype)
		{
			OverrideAdjustPlayMode (gtype, AdjustPlayModeVMCallback);
		}

		static void OverrideAdjustPlayMode (GLib.GType gtype, AdjustPlayModeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_mode"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int AdjustPlayModeNativeDelegate (IntPtr inst, IntPtr context, IntPtr range, int flags, double rate, ulong trickmode_interval, bool enable_rate_control);

		static int AdjustPlayMode_cb (IntPtr inst, IntPtr context, IntPtr range, int flags, double rate, ulong trickmode_interval, bool enable_rate_control)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnAdjustPlayMode (Gst.RtspServer.RTSPContext.New (context), Gst.Rtsp.RTSPTimeRange.New (range), (Gst.SeekFlags) flags, rate, trickmode_interval, enable_rate_control);
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAdjustPlayMode")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnAdjustPlayMode (Gst.RtspServer.RTSPContext context, Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags, double rate, ulong trickmode_interval, bool enable_rate_control)
		{
			return InternalAdjustPlayMode (context, range, flags, rate, trickmode_interval, enable_rate_control);
		}

		private Gst.Rtsp.RTSPStatusCode InternalAdjustPlayMode (Gst.RtspServer.RTSPContext context, Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags, double rate, ulong trickmode_interval, bool enable_rate_control)
		{
			AdjustPlayModeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_mode"));
				unmanaged = (AdjustPlayModeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AdjustPlayModeNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_context = GLib.Marshaller.StructureToPtrAlloc (context);
			IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
			int __result = unmanaged (this.Handle, native_context, native_range, (int) flags, rate, trickmode_interval, enable_rate_control);
			Marshal.FreeHGlobal (native_context);
			Marshal.FreeHGlobal (native_range);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static AdjustPlayResponseNativeDelegate AdjustPlayResponse_cb_delegate;
		static AdjustPlayResponseNativeDelegate AdjustPlayResponseVMCallback {
			get {
				if (AdjustPlayResponse_cb_delegate == null)
					AdjustPlayResponse_cb_delegate = new AdjustPlayResponseNativeDelegate (AdjustPlayResponse_cb);
				return AdjustPlayResponse_cb_delegate;
			}
		}

		static void OverrideAdjustPlayResponse (GLib.GType gtype)
		{
			OverrideAdjustPlayResponse (gtype, AdjustPlayResponseVMCallback);
		}

		static void OverrideAdjustPlayResponse (GLib.GType gtype, AdjustPlayResponseNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_response"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int AdjustPlayResponseNativeDelegate (IntPtr inst, IntPtr context);

		static int AdjustPlayResponse_cb (IntPtr inst, IntPtr context)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnAdjustPlayResponse (Gst.RtspServer.RTSPContext.New (context));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAdjustPlayResponse")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnAdjustPlayResponse (Gst.RtspServer.RTSPContext context)
		{
			return InternalAdjustPlayResponse (context);
		}

		private Gst.Rtsp.RTSPStatusCode InternalAdjustPlayResponse (Gst.RtspServer.RTSPContext context)
		{
			AdjustPlayResponseNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_response"));
				unmanaged = (AdjustPlayResponseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AdjustPlayResponseNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_context = GLib.Marshaller.StructureToPtrAlloc (context);
			int __result = unmanaged (this.Handle, native_context);
			Marshal.FreeHGlobal (native_context);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static ClosedNativeDelegate Closed_cb_delegate;
		static ClosedNativeDelegate ClosedVMCallback {
			get {
				if (Closed_cb_delegate == null)
					Closed_cb_delegate = new ClosedNativeDelegate (Closed_cb);
				return Closed_cb_delegate;
			}
		}

		static void OverrideClosed (GLib.GType gtype)
		{
			OverrideClosed (gtype, ClosedVMCallback);
		}

		static void OverrideClosed (GLib.GType gtype, ClosedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("closed"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ClosedNativeDelegate (IntPtr inst);

		static void Closed_cb (IntPtr inst)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnClosed ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideClosed")]
		protected virtual void OnClosed ()
		{
			InternalClosed ();
		}

		private void InternalClosed ()
		{
			ClosedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("closed"));
				unmanaged = (ClosedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ClosedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static NewSessionNativeDelegate NewSession_cb_delegate;
		static NewSessionNativeDelegate NewSessionVMCallback {
			get {
				if (NewSession_cb_delegate == null)
					NewSession_cb_delegate = new NewSessionNativeDelegate (NewSession_cb);
				return NewSession_cb_delegate;
			}
		}

		static void OverrideNewSession (GLib.GType gtype)
		{
			OverrideNewSession (gtype, NewSessionVMCallback);
		}

		static void OverrideNewSession (GLib.GType gtype, NewSessionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("new_session"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NewSessionNativeDelegate (IntPtr inst, IntPtr _object);

		static void NewSession_cb (IntPtr inst, IntPtr _object)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnNewSession (GLib.Object.GetObject(_object) as Gst.RtspServer.RTSPSession);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideNewSession")]
		protected virtual void OnNewSession (Gst.RtspServer.RTSPSession _object)
		{
			InternalNewSession (_object);
		}

		private void InternalNewSession (Gst.RtspServer.RTSPSession _object)
		{
			NewSessionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("new_session"));
				unmanaged = (NewSessionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NewSessionNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, _object == null ? IntPtr.Zero : _object.Handle);
		}

		static OptionsRequestNativeDelegate OptionsRequest_cb_delegate;
		static OptionsRequestNativeDelegate OptionsRequestVMCallback {
			get {
				if (OptionsRequest_cb_delegate == null)
					OptionsRequest_cb_delegate = new OptionsRequestNativeDelegate (OptionsRequest_cb);
				return OptionsRequest_cb_delegate;
			}
		}

		static void OverrideOptionsRequest (GLib.GType gtype)
		{
			OverrideOptionsRequest (gtype, OptionsRequestVMCallback);
		}

		static void OverrideOptionsRequest (GLib.GType gtype, OptionsRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("options_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void OptionsRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void OptionsRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnOptionsRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideOptionsRequest")]
		protected virtual void OnOptionsRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalOptionsRequest (ctx);
		}

		private void InternalOptionsRequest (Gst.RtspServer.RTSPContext ctx)
		{
			OptionsRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("options_request"));
				unmanaged = (OptionsRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(OptionsRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static DescribeRequestNativeDelegate DescribeRequest_cb_delegate;
		static DescribeRequestNativeDelegate DescribeRequestVMCallback {
			get {
				if (DescribeRequest_cb_delegate == null)
					DescribeRequest_cb_delegate = new DescribeRequestNativeDelegate (DescribeRequest_cb);
				return DescribeRequest_cb_delegate;
			}
		}

		static void OverrideDescribeRequest (GLib.GType gtype)
		{
			OverrideDescribeRequest (gtype, DescribeRequestVMCallback);
		}

		static void OverrideDescribeRequest (GLib.GType gtype, DescribeRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("describe_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DescribeRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void DescribeRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnDescribeRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideDescribeRequest")]
		protected virtual void OnDescribeRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalDescribeRequest (ctx);
		}

		private void InternalDescribeRequest (Gst.RtspServer.RTSPContext ctx)
		{
			DescribeRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("describe_request"));
				unmanaged = (DescribeRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DescribeRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static SetupRequestNativeDelegate SetupRequest_cb_delegate;
		static SetupRequestNativeDelegate SetupRequestVMCallback {
			get {
				if (SetupRequest_cb_delegate == null)
					SetupRequest_cb_delegate = new SetupRequestNativeDelegate (SetupRequest_cb);
				return SetupRequest_cb_delegate;
			}
		}

		static void OverrideSetupRequest (GLib.GType gtype)
		{
			OverrideSetupRequest (gtype, SetupRequestVMCallback);
		}

		static void OverrideSetupRequest (GLib.GType gtype, SetupRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetupRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void SetupRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnSetupRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideSetupRequest")]
		protected virtual void OnSetupRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalSetupRequest (ctx);
		}

		private void InternalSetupRequest (Gst.RtspServer.RTSPContext ctx)
		{
			SetupRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_request"));
				unmanaged = (SetupRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetupRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static PlayRequestNativeDelegate PlayRequest_cb_delegate;
		static PlayRequestNativeDelegate PlayRequestVMCallback {
			get {
				if (PlayRequest_cb_delegate == null)
					PlayRequest_cb_delegate = new PlayRequestNativeDelegate (PlayRequest_cb);
				return PlayRequest_cb_delegate;
			}
		}

		static void OverridePlayRequest (GLib.GType gtype)
		{
			OverridePlayRequest (gtype, PlayRequestVMCallback);
		}

		static void OverridePlayRequest (GLib.GType gtype, PlayRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("play_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PlayRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void PlayRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnPlayRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePlayRequest")]
		protected virtual void OnPlayRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalPlayRequest (ctx);
		}

		private void InternalPlayRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PlayRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("play_request"));
				unmanaged = (PlayRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PlayRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static PauseRequestNativeDelegate PauseRequest_cb_delegate;
		static PauseRequestNativeDelegate PauseRequestVMCallback {
			get {
				if (PauseRequest_cb_delegate == null)
					PauseRequest_cb_delegate = new PauseRequestNativeDelegate (PauseRequest_cb);
				return PauseRequest_cb_delegate;
			}
		}

		static void OverridePauseRequest (GLib.GType gtype)
		{
			OverridePauseRequest (gtype, PauseRequestVMCallback);
		}

		static void OverridePauseRequest (GLib.GType gtype, PauseRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pause_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PauseRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void PauseRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnPauseRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePauseRequest")]
		protected virtual void OnPauseRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalPauseRequest (ctx);
		}

		private void InternalPauseRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PauseRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pause_request"));
				unmanaged = (PauseRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PauseRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static TeardownRequestNativeDelegate TeardownRequest_cb_delegate;
		static TeardownRequestNativeDelegate TeardownRequestVMCallback {
			get {
				if (TeardownRequest_cb_delegate == null)
					TeardownRequest_cb_delegate = new TeardownRequestNativeDelegate (TeardownRequest_cb);
				return TeardownRequest_cb_delegate;
			}
		}

		static void OverrideTeardownRequest (GLib.GType gtype)
		{
			OverrideTeardownRequest (gtype, TeardownRequestVMCallback);
		}

		static void OverrideTeardownRequest (GLib.GType gtype, TeardownRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("teardown_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TeardownRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void TeardownRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnTeardownRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideTeardownRequest")]
		protected virtual void OnTeardownRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalTeardownRequest (ctx);
		}

		private void InternalTeardownRequest (Gst.RtspServer.RTSPContext ctx)
		{
			TeardownRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("teardown_request"));
				unmanaged = (TeardownRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TeardownRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static SetParameterRequestNativeDelegate SetParameterRequest_cb_delegate;
		static SetParameterRequestNativeDelegate SetParameterRequestVMCallback {
			get {
				if (SetParameterRequest_cb_delegate == null)
					SetParameterRequest_cb_delegate = new SetParameterRequestNativeDelegate (SetParameterRequest_cb);
				return SetParameterRequest_cb_delegate;
			}
		}

		static void OverrideSetParameterRequest (GLib.GType gtype)
		{
			OverrideSetParameterRequest (gtype, SetParameterRequestVMCallback);
		}

		static void OverrideSetParameterRequest (GLib.GType gtype, SetParameterRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parameter_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void SetParameterRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnSetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideSetParameterRequest")]
		protected virtual void OnSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalSetParameterRequest (ctx);
		}

		private void InternalSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			SetParameterRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parameter_request"));
				unmanaged = (SetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetParameterRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static GetParameterRequestNativeDelegate GetParameterRequest_cb_delegate;
		static GetParameterRequestNativeDelegate GetParameterRequestVMCallback {
			get {
				if (GetParameterRequest_cb_delegate == null)
					GetParameterRequest_cb_delegate = new GetParameterRequestNativeDelegate (GetParameterRequest_cb);
				return GetParameterRequest_cb_delegate;
			}
		}

		static void OverrideGetParameterRequest (GLib.GType gtype)
		{
			OverrideGetParameterRequest (gtype, GetParameterRequestVMCallback);
		}

		static void OverrideGetParameterRequest (GLib.GType gtype, GetParameterRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_parameter_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void GetParameterRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnGetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideGetParameterRequest")]
		protected virtual void OnGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalGetParameterRequest (ctx);
		}

		private void InternalGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			GetParameterRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_parameter_request"));
				unmanaged = (GetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetParameterRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static HandleResponseNativeDelegate HandleResponse_cb_delegate;
		static HandleResponseNativeDelegate HandleResponseVMCallback {
			get {
				if (HandleResponse_cb_delegate == null)
					HandleResponse_cb_delegate = new HandleResponseNativeDelegate (HandleResponse_cb);
				return HandleResponse_cb_delegate;
			}
		}

		static void OverrideHandleResponse (GLib.GType gtype)
		{
			OverrideHandleResponse (gtype, HandleResponseVMCallback);
		}

		static void OverrideHandleResponse (GLib.GType gtype, HandleResponseNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_response"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void HandleResponseNativeDelegate (IntPtr inst, IntPtr ctx);

		static void HandleResponse_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnHandleResponse (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideHandleResponse")]
		protected virtual void OnHandleResponse (Gst.RtspServer.RTSPContext ctx)
		{
			InternalHandleResponse (ctx);
		}

		private void InternalHandleResponse (Gst.RtspServer.RTSPContext ctx)
		{
			HandleResponseNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_response"));
				unmanaged = (HandleResponseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleResponseNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static TunnelHttpResponseNativeDelegate TunnelHttpResponse_cb_delegate;
		static TunnelHttpResponseNativeDelegate TunnelHttpResponseVMCallback {
			get {
				if (TunnelHttpResponse_cb_delegate == null)
					TunnelHttpResponse_cb_delegate = new TunnelHttpResponseNativeDelegate (TunnelHttpResponse_cb);
				return TunnelHttpResponse_cb_delegate;
			}
		}

		static void OverrideTunnelHttpResponse (GLib.GType gtype)
		{
			OverrideTunnelHttpResponse (gtype, TunnelHttpResponseVMCallback);
		}

		static void OverrideTunnelHttpResponse (GLib.GType gtype, TunnelHttpResponseNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("tunnel_http_response"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TunnelHttpResponseNativeDelegate (IntPtr inst, IntPtr request, IntPtr response);

		static void TunnelHttpResponse_cb (IntPtr inst, IntPtr request, IntPtr response)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnTunnelHttpResponse (Gst.Rtsp.RTSPMessage.New (request), Gst.Rtsp.RTSPMessage.New (response));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideTunnelHttpResponse")]
		protected virtual void OnTunnelHttpResponse (Gst.Rtsp.RTSPMessage request, Gst.Rtsp.RTSPMessage response)
		{
			InternalTunnelHttpResponse (request, response);
		}

		private void InternalTunnelHttpResponse (Gst.Rtsp.RTSPMessage request, Gst.Rtsp.RTSPMessage response)
		{
			TunnelHttpResponseNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("tunnel_http_response"));
				unmanaged = (TunnelHttpResponseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TunnelHttpResponseNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_request = GLib.Marshaller.StructureToPtrAlloc (request);
			IntPtr native_response = GLib.Marshaller.StructureToPtrAlloc (response);
			unmanaged (this.Handle, native_request, native_response);
			Marshal.FreeHGlobal (native_request);
			Marshal.FreeHGlobal (native_response);
		}

		static SendMessageEventNativeDelegate SendMessageEvent_cb_delegate;
		static SendMessageEventNativeDelegate SendMessageEventVMCallback {
			get {
				if (SendMessageEvent_cb_delegate == null)
					SendMessageEvent_cb_delegate = new SendMessageEventNativeDelegate (SendMessageEvent_cb);
				return SendMessageEvent_cb_delegate;
			}
		}

		static void OverrideSendMessageEvent (GLib.GType gtype)
		{
			OverrideSendMessageEvent (gtype, SendMessageEventVMCallback);
		}

		static void OverrideSendMessageEvent (GLib.GType gtype, SendMessageEventNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("send_message"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SendMessageEventNativeDelegate (IntPtr inst, IntPtr session, IntPtr message);

		static void SendMessageEvent_cb (IntPtr inst, IntPtr session, IntPtr message)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnSendMessageEvent (GLib.Object.GetObject(session) as Gst.RtspServer.RTSPSession, message);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideSendMessageEvent")]
		protected virtual void OnSendMessageEvent (Gst.RtspServer.RTSPSession session, IntPtr message)
		{
			InternalSendMessageEvent (session, message);
		}

		private void InternalSendMessageEvent (Gst.RtspServer.RTSPSession session, IntPtr message)
		{
			SendMessageEventNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("send_message"));
				unmanaged = (SendMessageEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SendMessageEventNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, session == null ? IntPtr.Zero : session.Handle, message);
		}

		static HandleSdpNativeDelegate HandleSdp_cb_delegate;
		static HandleSdpNativeDelegate HandleSdpVMCallback {
			get {
				if (HandleSdp_cb_delegate == null)
					HandleSdp_cb_delegate = new HandleSdpNativeDelegate (HandleSdp_cb);
				return HandleSdp_cb_delegate;
			}
		}

		static void OverrideHandleSdp (GLib.GType gtype)
		{
			OverrideHandleSdp (gtype, HandleSdpVMCallback);
		}

		static void OverrideHandleSdp (GLib.GType gtype, HandleSdpNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_sdp"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool HandleSdpNativeDelegate (IntPtr inst, IntPtr ctx, IntPtr media, IntPtr sdp);

		static bool HandleSdp_cb (IntPtr inst, IntPtr ctx, IntPtr media, IntPtr sdp)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				bool __result;
				__result = __obj.OnHandleSdp (Gst.RtspServer.RTSPContext.New (ctx), GLib.Object.GetObject(media) as Gst.RtspServer.RTSPMedia, sdp == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (sdp, typeof (Gst.Sdp.SDPMessage), false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideHandleSdp")]
		protected virtual bool OnHandleSdp (Gst.RtspServer.RTSPContext ctx, Gst.RtspServer.RTSPMedia media, Gst.Sdp.SDPMessage sdp)
		{
			return InternalHandleSdp (ctx, media, sdp);
		}

		private bool InternalHandleSdp (Gst.RtspServer.RTSPContext ctx, Gst.RtspServer.RTSPMedia media, Gst.Sdp.SDPMessage sdp)
		{
			HandleSdpNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_sdp"));
				unmanaged = (HandleSdpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleSdpNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			bool __result = unmanaged (this.Handle, native_ctx, media == null ? IntPtr.Zero : media.Handle, sdp == null ? IntPtr.Zero : sdp.Handle);
			Marshal.FreeHGlobal (native_ctx);
			return __result;
		}

		static AnnounceRequestNativeDelegate AnnounceRequest_cb_delegate;
		static AnnounceRequestNativeDelegate AnnounceRequestVMCallback {
			get {
				if (AnnounceRequest_cb_delegate == null)
					AnnounceRequest_cb_delegate = new AnnounceRequestNativeDelegate (AnnounceRequest_cb);
				return AnnounceRequest_cb_delegate;
			}
		}

		static void OverrideAnnounceRequest (GLib.GType gtype)
		{
			OverrideAnnounceRequest (gtype, AnnounceRequestVMCallback);
		}

		static void OverrideAnnounceRequest (GLib.GType gtype, AnnounceRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("announce_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AnnounceRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void AnnounceRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnAnnounceRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAnnounceRequest")]
		protected virtual void OnAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalAnnounceRequest (ctx);
		}

		private void InternalAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
		{
			AnnounceRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("announce_request"));
				unmanaged = (AnnounceRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AnnounceRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static RecordRequestNativeDelegate RecordRequest_cb_delegate;
		static RecordRequestNativeDelegate RecordRequestVMCallback {
			get {
				if (RecordRequest_cb_delegate == null)
					RecordRequest_cb_delegate = new RecordRequestNativeDelegate (RecordRequest_cb);
				return RecordRequest_cb_delegate;
			}
		}

		static void OverrideRecordRequest (GLib.GType gtype)
		{
			OverrideRecordRequest (gtype, RecordRequestVMCallback);
		}

		static void OverrideRecordRequest (GLib.GType gtype, RecordRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("record_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RecordRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static void RecordRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				__obj.OnRecordRequest (Gst.RtspServer.RTSPContext.New (ctx));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideRecordRequest")]
		protected virtual void OnRecordRequest (Gst.RtspServer.RTSPContext ctx)
		{
			InternalRecordRequest (ctx);
		}

		private void InternalRecordRequest (Gst.RtspServer.RTSPContext ctx)
		{
			RecordRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("record_request"));
				unmanaged = (RecordRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RecordRequestNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
		}

		static PreOptionsRequestNativeDelegate PreOptionsRequest_cb_delegate;
		static PreOptionsRequestNativeDelegate PreOptionsRequestVMCallback {
			get {
				if (PreOptionsRequest_cb_delegate == null)
					PreOptionsRequest_cb_delegate = new PreOptionsRequestNativeDelegate (PreOptionsRequest_cb);
				return PreOptionsRequest_cb_delegate;
			}
		}

		static void OverridePreOptionsRequest (GLib.GType gtype)
		{
			OverridePreOptionsRequest (gtype, PreOptionsRequestVMCallback);
		}

		static void OverridePreOptionsRequest (GLib.GType gtype, PreOptionsRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_options_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreOptionsRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreOptionsRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreOptionsRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreOptionsRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreOptionsRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreOptionsRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreOptionsRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreOptionsRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_options_request"));
				unmanaged = (PreOptionsRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreOptionsRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PreDescribeRequestNativeDelegate PreDescribeRequest_cb_delegate;
		static PreDescribeRequestNativeDelegate PreDescribeRequestVMCallback {
			get {
				if (PreDescribeRequest_cb_delegate == null)
					PreDescribeRequest_cb_delegate = new PreDescribeRequestNativeDelegate (PreDescribeRequest_cb);
				return PreDescribeRequest_cb_delegate;
			}
		}

		static void OverridePreDescribeRequest (GLib.GType gtype)
		{
			OverridePreDescribeRequest (gtype, PreDescribeRequestVMCallback);
		}

		static void OverridePreDescribeRequest (GLib.GType gtype, PreDescribeRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_describe_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreDescribeRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreDescribeRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreDescribeRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreDescribeRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreDescribeRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreDescribeRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreDescribeRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreDescribeRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_describe_request"));
				unmanaged = (PreDescribeRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreDescribeRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PreSetupRequestNativeDelegate PreSetupRequest_cb_delegate;
		static PreSetupRequestNativeDelegate PreSetupRequestVMCallback {
			get {
				if (PreSetupRequest_cb_delegate == null)
					PreSetupRequest_cb_delegate = new PreSetupRequestNativeDelegate (PreSetupRequest_cb);
				return PreSetupRequest_cb_delegate;
			}
		}

		static void OverridePreSetupRequest (GLib.GType gtype)
		{
			OverridePreSetupRequest (gtype, PreSetupRequestVMCallback);
		}

		static void OverridePreSetupRequest (GLib.GType gtype, PreSetupRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_setup_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreSetupRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreSetupRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreSetupRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreSetupRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreSetupRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreSetupRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreSetupRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreSetupRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_setup_request"));
				unmanaged = (PreSetupRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreSetupRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PrePlayRequestNativeDelegate PrePlayRequest_cb_delegate;
		static PrePlayRequestNativeDelegate PrePlayRequestVMCallback {
			get {
				if (PrePlayRequest_cb_delegate == null)
					PrePlayRequest_cb_delegate = new PrePlayRequestNativeDelegate (PrePlayRequest_cb);
				return PrePlayRequest_cb_delegate;
			}
		}

		static void OverridePrePlayRequest (GLib.GType gtype)
		{
			OverridePrePlayRequest (gtype, PrePlayRequestVMCallback);
		}

		static void OverridePrePlayRequest (GLib.GType gtype, PrePlayRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_play_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PrePlayRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PrePlayRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPrePlayRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePrePlayRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPrePlayRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPrePlayRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPrePlayRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PrePlayRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_play_request"));
				unmanaged = (PrePlayRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrePlayRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PrePauseRequestNativeDelegate PrePauseRequest_cb_delegate;
		static PrePauseRequestNativeDelegate PrePauseRequestVMCallback {
			get {
				if (PrePauseRequest_cb_delegate == null)
					PrePauseRequest_cb_delegate = new PrePauseRequestNativeDelegate (PrePauseRequest_cb);
				return PrePauseRequest_cb_delegate;
			}
		}

		static void OverridePrePauseRequest (GLib.GType gtype)
		{
			OverridePrePauseRequest (gtype, PrePauseRequestVMCallback);
		}

		static void OverridePrePauseRequest (GLib.GType gtype, PrePauseRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_pause_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PrePauseRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PrePauseRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPrePauseRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePrePauseRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPrePauseRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPrePauseRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPrePauseRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PrePauseRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_pause_request"));
				unmanaged = (PrePauseRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrePauseRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PreTeardownRequestNativeDelegate PreTeardownRequest_cb_delegate;
		static PreTeardownRequestNativeDelegate PreTeardownRequestVMCallback {
			get {
				if (PreTeardownRequest_cb_delegate == null)
					PreTeardownRequest_cb_delegate = new PreTeardownRequestNativeDelegate (PreTeardownRequest_cb);
				return PreTeardownRequest_cb_delegate;
			}
		}

		static void OverridePreTeardownRequest (GLib.GType gtype)
		{
			OverridePreTeardownRequest (gtype, PreTeardownRequestVMCallback);
		}

		static void OverridePreTeardownRequest (GLib.GType gtype, PreTeardownRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_teardown_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreTeardownRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreTeardownRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreTeardownRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreTeardownRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreTeardownRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreTeardownRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreTeardownRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreTeardownRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_teardown_request"));
				unmanaged = (PreTeardownRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreTeardownRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PreSetParameterRequestNativeDelegate PreSetParameterRequest_cb_delegate;
		static PreSetParameterRequestNativeDelegate PreSetParameterRequestVMCallback {
			get {
				if (PreSetParameterRequest_cb_delegate == null)
					PreSetParameterRequest_cb_delegate = new PreSetParameterRequestNativeDelegate (PreSetParameterRequest_cb);
				return PreSetParameterRequest_cb_delegate;
			}
		}

		static void OverridePreSetParameterRequest (GLib.GType gtype)
		{
			OverridePreSetParameterRequest (gtype, PreSetParameterRequestVMCallback);
		}

		static void OverridePreSetParameterRequest (GLib.GType gtype, PreSetParameterRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_set_parameter_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreSetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreSetParameterRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreSetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreSetParameterRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreSetParameterRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreSetParameterRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_set_parameter_request"));
				unmanaged = (PreSetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreSetParameterRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PreGetParameterRequestNativeDelegate PreGetParameterRequest_cb_delegate;
		static PreGetParameterRequestNativeDelegate PreGetParameterRequestVMCallback {
			get {
				if (PreGetParameterRequest_cb_delegate == null)
					PreGetParameterRequest_cb_delegate = new PreGetParameterRequestNativeDelegate (PreGetParameterRequest_cb);
				return PreGetParameterRequest_cb_delegate;
			}
		}

		static void OverridePreGetParameterRequest (GLib.GType gtype)
		{
			OverridePreGetParameterRequest (gtype, PreGetParameterRequestVMCallback);
		}

		static void OverridePreGetParameterRequest (GLib.GType gtype, PreGetParameterRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_get_parameter_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreGetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreGetParameterRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreGetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreGetParameterRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreGetParameterRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreGetParameterRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_get_parameter_request"));
				unmanaged = (PreGetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreGetParameterRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PreAnnounceRequestNativeDelegate PreAnnounceRequest_cb_delegate;
		static PreAnnounceRequestNativeDelegate PreAnnounceRequestVMCallback {
			get {
				if (PreAnnounceRequest_cb_delegate == null)
					PreAnnounceRequest_cb_delegate = new PreAnnounceRequestNativeDelegate (PreAnnounceRequest_cb);
				return PreAnnounceRequest_cb_delegate;
			}
		}

		static void OverridePreAnnounceRequest (GLib.GType gtype)
		{
			OverridePreAnnounceRequest (gtype, PreAnnounceRequestVMCallback);
		}

		static void OverridePreAnnounceRequest (GLib.GType gtype, PreAnnounceRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_announce_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreAnnounceRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreAnnounceRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreAnnounceRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreAnnounceRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreAnnounceRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreAnnounceRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_announce_request"));
				unmanaged = (PreAnnounceRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreAnnounceRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static PreRecordRequestNativeDelegate PreRecordRequest_cb_delegate;
		static PreRecordRequestNativeDelegate PreRecordRequestVMCallback {
			get {
				if (PreRecordRequest_cb_delegate == null)
					PreRecordRequest_cb_delegate = new PreRecordRequestNativeDelegate (PreRecordRequest_cb);
				return PreRecordRequest_cb_delegate;
			}
		}

		static void OverridePreRecordRequest (GLib.GType gtype)
		{
			OverridePreRecordRequest (gtype, PreRecordRequestVMCallback);
		}

		static void OverridePreRecordRequest (GLib.GType gtype, PreRecordRequestNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_record_request"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int PreRecordRequestNativeDelegate (IntPtr inst, IntPtr ctx);

		static int PreRecordRequest_cb (IntPtr inst, IntPtr ctx)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnPreRecordRequest (Gst.RtspServer.RTSPContext.New (ctx));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreRecordRequest")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnPreRecordRequest (Gst.RtspServer.RTSPContext ctx)
		{
			return InternalPreRecordRequest (ctx);
		}

		private Gst.Rtsp.RTSPStatusCode InternalPreRecordRequest (Gst.RtspServer.RTSPContext ctx)
		{
			PreRecordRequestNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_record_request"));
				unmanaged = (PreRecordRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreRecordRequestNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}

		static AdjustErrorCodeNativeDelegate AdjustErrorCode_cb_delegate;
		static AdjustErrorCodeNativeDelegate AdjustErrorCodeVMCallback {
			get {
				if (AdjustErrorCode_cb_delegate == null)
					AdjustErrorCode_cb_delegate = new AdjustErrorCodeNativeDelegate (AdjustErrorCode_cb);
				return AdjustErrorCode_cb_delegate;
			}
		}

		static void OverrideAdjustErrorCode (GLib.GType gtype)
		{
			OverrideAdjustErrorCode (gtype, AdjustErrorCodeVMCallback);
		}

		static void OverrideAdjustErrorCode (GLib.GType gtype, AdjustErrorCodeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_error_code"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int AdjustErrorCodeNativeDelegate (IntPtr inst, IntPtr ctx, int code);

		static int AdjustErrorCode_cb (IntPtr inst, IntPtr ctx, int code)
		{
			try {
				RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
				Gst.Rtsp.RTSPStatusCode __result;
				__result = __obj.OnAdjustErrorCode (Gst.RtspServer.RTSPContext.New (ctx), (Gst.Rtsp.RTSPStatusCode) code);
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAdjustErrorCode")]
		protected virtual Gst.Rtsp.RTSPStatusCode OnAdjustErrorCode (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPStatusCode code)
		{
			return InternalAdjustErrorCode (ctx, code);
		}

		private Gst.Rtsp.RTSPStatusCode InternalAdjustErrorCode (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPStatusCode code)
		{
			AdjustErrorCodeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_error_code"));
				unmanaged = (AdjustErrorCodeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AdjustErrorCodeNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;

			IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
			int __result = unmanaged (this.Handle, native_ctx, (int) code);
			Marshal.FreeHGlobal (native_ctx);
			return (Gst.Rtsp.RTSPStatusCode) __result;
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("create_sdp"
							, GLib.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_sdp
							, null
							, "configure_client_media"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("configure_client_media"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // configure_client_media
							, "create_sdp"
							, "configure_client_transport"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("configure_client_transport"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // configure_client_transport
							, "configure_client_media"
							, "params_set"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("params_set"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // params_set
							, "configure_client_transport"
							, "params_get"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("params_get"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // params_get
							, "params_set"
							, "make_path_from_uri"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("make_path_from_uri"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // make_path_from_uri
							, "params_get"
							, "adjust_play_mode"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("adjust_play_mode"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // adjust_play_mode
							, "make_path_from_uri"
							, "adjust_play_response"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("adjust_play_response"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // adjust_play_response
							, "adjust_play_mode"
							, "closed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("closed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // closed
							, "adjust_play_response"
							, "new_session"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("new_session"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // new_session
							, "closed"
							, "options_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("options_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // options_request
							, "new_session"
							, "describe_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("describe_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // describe_request
							, "options_request"
							, "setup_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("setup_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // setup_request
							, "describe_request"
							, "play_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("play_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // play_request
							, "setup_request"
							, "pause_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pause_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pause_request
							, "play_request"
							, "teardown_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("teardown_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // teardown_request
							, "pause_request"
							, "set_parameter_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_parameter_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_parameter_request
							, "teardown_request"
							, "get_parameter_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_parameter_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_parameter_request
							, "set_parameter_request"
							, "handle_response"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("handle_response"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_response
							, "get_parameter_request"
							, "tunnel_http_response"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("tunnel_http_response"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // tunnel_http_response
							, "handle_response"
							, "send_message"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("send_message"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // send_message
							, "tunnel_http_response"
							, "handle_sdp"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("handle_sdp"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_sdp
							, "send_message"
							, "announce_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("announce_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // announce_request
							, "handle_sdp"
							, "record_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("record_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // record_request
							, "announce_request"
							, "check_requirements"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("check_requirements"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // check_requirements
							, "record_request"
							, "pre_options_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_options_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_options_request
							, "check_requirements"
							, "pre_describe_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_describe_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_describe_request
							, "pre_options_request"
							, "pre_setup_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_setup_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_setup_request
							, "pre_describe_request"
							, "pre_play_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_play_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_play_request
							, "pre_setup_request"
							, "pre_pause_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_pause_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_pause_request
							, "pre_play_request"
							, "pre_teardown_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_teardown_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_teardown_request
							, "pre_pause_request"
							, "pre_set_parameter_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_set_parameter_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_set_parameter_request
							, "pre_teardown_request"
							, "pre_get_parameter_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_get_parameter_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_get_parameter_request
							, "pre_set_parameter_request"
							, "pre_announce_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_announce_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_announce_request
							, "pre_get_parameter_request"
							, "pre_record_request"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pre_record_request"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_record_request
							, "pre_announce_request"
							, "adjust_error_code"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("adjust_error_code"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // adjust_error_code
							, "pre_record_request"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 1 // _gst_reserved
							, "adjust_error_code"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_get_type();

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = gst_rtsp_client_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_rtsp_client_attach(IntPtr raw, IntPtr context);

		public uint Attach(GLib.MainContext context) {
			uint raw_ret = gst_rtsp_client_attach(Handle, context == null ? IntPtr.Zero : context.Handle);
			uint ret = raw_ret;
			return ret;
		}

		public uint Attach() {
			return Attach (null);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_close(IntPtr raw);

		public void Close() {
			gst_rtsp_client_close(Handle);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_get_auth(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_set_auth(IntPtr raw, IntPtr auth);

		public Gst.RtspServer.RTSPAuth Auth { 
			get {
				IntPtr raw_ret = gst_rtsp_client_get_auth(Handle);
				Gst.RtspServer.RTSPAuth ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPAuth;
				return ret;
			}
			set {
				gst_rtsp_client_set_auth(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_get_connection(IntPtr raw);

		public Gst.Rtsp.RTSPConnection Connection { 
			get {
				IntPtr raw_ret = gst_rtsp_client_get_connection(Handle);
				Gst.Rtsp.RTSPConnection ret = raw_ret == IntPtr.Zero ? null : (Gst.Rtsp.RTSPConnection) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Rtsp.RTSPConnection), false);
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_rtsp_client_get_content_length_limit(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_set_content_length_limit(IntPtr raw, uint limit);

		public uint ContentLengthLimit { 
			get {
				uint raw_ret = gst_rtsp_client_get_content_length_limit(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_client_set_content_length_limit(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_get_stream_transport(IntPtr raw, byte channel);

		public Gst.RtspServer.RTSPStreamTransport GetStreamTransport(byte channel) {
			IntPtr raw_ret = gst_rtsp_client_get_stream_transport(Handle, channel);
			Gst.RtspServer.RTSPStreamTransport ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStreamTransport;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_get_thread_pool(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_set_thread_pool(IntPtr raw, IntPtr pool);

		public Gst.RtspServer.RTSPThreadPool ThreadPool { 
			get {
				IntPtr raw_ret = gst_rtsp_client_get_thread_pool(Handle);
				Gst.RtspServer.RTSPThreadPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPThreadPool;
				return ret;
			}
			set {
				gst_rtsp_client_set_thread_pool(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_client_handle_message(IntPtr raw, IntPtr message);

		public Gst.Rtsp.RTSPResult HandleMessage(Gst.Rtsp.RTSPMessage message) {
			IntPtr native_message = GLib.Marshaller.StructureToPtrAlloc (message);
			int raw_ret = gst_rtsp_client_handle_message(Handle, native_message);
			Gst.Rtsp.RTSPResult ret = (Gst.Rtsp.RTSPResult) raw_ret;
			Marshal.FreeHGlobal (native_message);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_client_send_message(IntPtr raw, IntPtr session, IntPtr message);

		public Gst.Rtsp.RTSPResult SendMessage(Gst.RtspServer.RTSPSession session, Gst.Rtsp.RTSPMessage message) {
			IntPtr native_message = GLib.Marshaller.StructureToPtrAlloc (message);
			int raw_ret = gst_rtsp_client_send_message(Handle, session == null ? IntPtr.Zero : session.Handle, native_message);
			Gst.Rtsp.RTSPResult ret = (Gst.Rtsp.RTSPResult) raw_ret;
			Marshal.FreeHGlobal (native_message);
			return ret;
		}

		public Gst.Rtsp.RTSPResult SendMessage(Gst.Rtsp.RTSPMessage message) {
			return SendMessage (null, message);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_client_session_filter(IntPtr raw, Gst.RtspServerSharp.RTSPClientSessionFilterFuncNative func, IntPtr user_data);

		public Gst.RtspServer.RTSPSession[] SessionFilter(Gst.RtspServer.RTSPClientSessionFilterFunc func) {
			Gst.RtspServerSharp.RTSPClientSessionFilterFuncWrapper func_wrapper = new Gst.RtspServerSharp.RTSPClientSessionFilterFuncWrapper (func);
			IntPtr raw_ret = gst_rtsp_client_session_filter(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
			Gst.RtspServer.RTSPSession[] ret = (Gst.RtspServer.RTSPSession[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(Gst.RtspServer.RTSPSession));
			return ret;
		}

		public Gst.RtspServer.RTSPSession[] SessionFilter() {
			return SessionFilter (null);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_client_set_connection(IntPtr raw, IntPtr conn);

		public bool SetConnection(Gst.Rtsp.RTSPConnection conn) {
			conn.Owned = false;
			bool raw_ret = gst_rtsp_client_set_connection(Handle, conn == null ? IntPtr.Zero : conn.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_set_send_func(IntPtr raw, Gst.RtspServerSharp.RTSPClientSendFuncNative func, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.RtspServer.RTSPClientSendFunc SendFunc { 
			set {
				Gst.RtspServerSharp.RTSPClientSendFuncWrapper value_wrapper = new Gst.RtspServerSharp.RTSPClientSendFuncWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_rtsp_client_set_send_func(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_client_set_send_messages_func(IntPtr raw, Gst.RtspServerSharp.RTSPClientSendMessagesFuncNative func, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.RtspServer.RTSPClientSendMessagesFunc SendMessagesFunc { 
			set {
				Gst.RtspServerSharp.RTSPClientSendMessagesFuncWrapper value_wrapper = new Gst.RtspServerSharp.RTSPClientSendMessagesFuncWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_rtsp_client_set_send_messages_func(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}


		static RTSPClient ()
		{
			GtkSharp.GstreamerSharp.ObjectManager.Initialize ();
		}

		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("priv"
							, GLib.Object.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
							, null
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
							, "priv"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
