Layout for a typical GLib.TypeModule implementation (replace `Simple` by the name of your class/interface)

simple-custom.vala

using GLib;

[ModuleInit]
public Type simple_init (TypeModule type_module) 
{
	return typeof (CustomSimple);
}

public class CustomSimple : Simple
{
	// TODO: implementation
}

simple-module.vala

using GLib;

public delegate Type SimpleInitFunc (TypeModule type_module);

public class SimpleModule : TypeModule
{
	public string? directory { get; construct; }

	public string name { get; construct; }

	public string path { get; construct; }

	public Type simple_type { get; private set; }

	private Module? module;

	public SimpleModule (string? directory, string name)
	{
		Object (directory: directory, name: name);
	}

	construct
	{
		path = Module.build_path (directory, "simple-%s".printf (name));
	}

	public override bool load ()
	{
		module = Module.open (path, ModuleFlags.BIND_LAZY);

		if (module == null)
		{
			critical (Module.error ());
			return false;
		}

		void* func;
		if (!module.symbol ("simple_init", out func))
		{
			critical (Module.error ());
			return false;
		}

		if (func == null)
		{
			critical ("No registration function was found in '%s'.", path);
			return false;
		}

		simple_type = ((SimpleInitFunc) func) (this);

		if (!simple_type.is_a (typeof (Simple)))
		{
			critical ("The registration function must return a type derived from '%s'", typeof (Simple).name ());
			return false;
		}

		return true;
	}

	public override void unload ()
	{
		module = null;
	}
}

simple.vala

public abstract class Simple 
{
	// TODO: interface
}