// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package gio

import (
	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/glib"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
)

// A type for representing D-Bus messages that can be sent or received
// on a [class@Gio.DBusConnection].
type DBusMessage struct {
	gobject.Object
}

var xDBusMessageGLibType func() types.GType

func DBusMessageGLibType() types.GType {
	return xDBusMessageGLibType()
}

func DBusMessageNewFromInternalPtr(ptr uintptr) *DBusMessage {
	cls := &DBusMessage{}
	cls.Ptr = ptr
	return cls
}

var xNewDBusMessage func() uintptr

// Creates a new empty #GDBusMessage.
func NewDBusMessage() *DBusMessage {
	var cls *DBusMessage

	cret := xNewDBusMessage()

	if cret == 0 {
		return nil
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	return cls
}

var xNewDBusMessageFromBlob func([]byte, uint, DBusCapabilityFlags, **glib.Error) uintptr

// Creates a new #GDBusMessage from the data stored at @blob. The byte
// order that the message was in can be retrieved using
// g_dbus_message_get_byte_order().
//
// If the @blob cannot be parsed, contains invalid fields, or contains invalid
// headers, %G_IO_ERROR_INVALID_ARGUMENT will be returned.
func NewDBusMessageFromBlob(BlobVar []byte, BlobLenVar uint, CapabilitiesVar DBusCapabilityFlags) (*DBusMessage, error) {
	var cls *DBusMessage
	var cerr *glib.Error

	cret := xNewDBusMessageFromBlob(BlobVar, BlobLenVar, CapabilitiesVar, &cerr)

	if cret == 0 {
		return nil, cerr
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	if cerr == nil {
		return cls, nil
	}
	return cls, cerr

}

var xNewDBusMessageMethodCall func(uintptr, string, uintptr, string) uintptr

// Creates a new #GDBusMessage for a method call.
func NewDBusMessageMethodCall(NameVar *string, PathVar string, InterfaceVar *string, MethodVar string) *DBusMessage {
	var cls *DBusMessage

	NameVarPtr := core.GStrdupNullable(NameVar)
	defer core.GFreeNullable(NameVarPtr)

	InterfaceVarPtr := core.GStrdupNullable(InterfaceVar)
	defer core.GFreeNullable(InterfaceVarPtr)

	cret := xNewDBusMessageMethodCall(NameVarPtr, PathVar, InterfaceVarPtr, MethodVar)

	if cret == 0 {
		return nil
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	return cls
}

var xNewDBusMessageSignal func(string, string, string) uintptr

// Creates a new #GDBusMessage for a signal emission.
func NewDBusMessageSignal(PathVar string, InterfaceVar string, SignalVar string) *DBusMessage {
	var cls *DBusMessage

	cret := xNewDBusMessageSignal(PathVar, InterfaceVar, SignalVar)

	if cret == 0 {
		return nil
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	return cls
}

var xDBusMessageCopy func(uintptr) uintptr

// Copies @message. The copy is a deep copy and the returned
// #GDBusMessage is completely identical except that it is guaranteed
// to not be locked.
//
// This operation can fail if e.g. @message contains file descriptors
// and the per-process or system-wide open files limit is reached.
func (x *DBusMessage) Copy() (*DBusMessage, error) {
	var cls *DBusMessage
	var cerr *glib.Error

	cret := xDBusMessageCopy(x.GoPointer())

	if cret == 0 {
		return nil, cerr
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	if cerr == nil {
		return cls, nil
	}
	return cls, cerr

}

var xDBusMessageGetArg0 func(uintptr) string

// Convenience to get the first item in the body of @message.
//
// See [method@Gio.DBusMessage.get_arg0_path] for returning object-path-typed
// arg0 values.
func (x *DBusMessage) GetArg0() string {

	cret := xDBusMessageGetArg0(x.GoPointer())
	return cret
}

var xDBusMessageGetArg0Path func(uintptr) string

// Convenience to get the first item in the body of @message.
//
// See [method@Gio.DBusMessage.get_arg0] for returning string-typed arg0 values.
func (x *DBusMessage) GetArg0Path() string {

	cret := xDBusMessageGetArg0Path(x.GoPointer())
	return cret
}

var xDBusMessageGetBody func(uintptr) *glib.Variant

// Gets the body of a message.
func (x *DBusMessage) GetBody() *glib.Variant {

	cret := xDBusMessageGetBody(x.GoPointer())
	return cret
}

var xDBusMessageGetByteOrder func(uintptr) DBusMessageByteOrder

// Gets the byte order of @message.
func (x *DBusMessage) GetByteOrder() DBusMessageByteOrder {

	cret := xDBusMessageGetByteOrder(x.GoPointer())
	return cret
}

var xDBusMessageGetDestination func(uintptr) string

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
func (x *DBusMessage) GetDestination() string {

	cret := xDBusMessageGetDestination(x.GoPointer())
	return cret
}

var xDBusMessageGetErrorName func(uintptr) string

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
func (x *DBusMessage) GetErrorName() string {

	cret := xDBusMessageGetErrorName(x.GoPointer())
	return cret
}

var xDBusMessageGetFlags func(uintptr) DBusMessageFlags

// Gets the flags for @message.
func (x *DBusMessage) GetFlags() DBusMessageFlags {

	cret := xDBusMessageGetFlags(x.GoPointer())
	return cret
}

var xDBusMessageGetHeader func(uintptr, DBusMessageHeaderField) *glib.Variant

// Gets a header field on @message.
//
// The caller is responsible for checking the type of the returned #GVariant
// matches what is expected.
func (x *DBusMessage) GetHeader(HeaderFieldVar DBusMessageHeaderField) *glib.Variant {

	cret := xDBusMessageGetHeader(x.GoPointer(), HeaderFieldVar)
	return cret
}

var xDBusMessageGetHeaderFields func(uintptr) uintptr

// Gets an array of all header fields on @message that are set.
func (x *DBusMessage) GetHeaderFields() uintptr {

	cret := xDBusMessageGetHeaderFields(x.GoPointer())
	return cret
}

var xDBusMessageGetInterface func(uintptr) string

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
func (x *DBusMessage) GetInterface() string {

	cret := xDBusMessageGetInterface(x.GoPointer())
	return cret
}

var xDBusMessageGetLocked func(uintptr) bool

// Checks whether @message is locked. To monitor changes to this
// value, connect to the #GObject::notify signal to listen for changes
// on the #GDBusMessage:locked property.
func (x *DBusMessage) GetLocked() bool {

	cret := xDBusMessageGetLocked(x.GoPointer())
	return cret
}

var xDBusMessageGetMember func(uintptr) string

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
func (x *DBusMessage) GetMember() string {

	cret := xDBusMessageGetMember(x.GoPointer())
	return cret
}

var xDBusMessageGetMessageType func(uintptr) DBusMessageType

// Gets the type of @message.
func (x *DBusMessage) GetMessageType() DBusMessageType {

	cret := xDBusMessageGetMessageType(x.GoPointer())
	return cret
}

var xDBusMessageGetNumUnixFds func(uintptr) uint32

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
func (x *DBusMessage) GetNumUnixFds() uint32 {

	cret := xDBusMessageGetNumUnixFds(x.GoPointer())
	return cret
}

var xDBusMessageGetPath func(uintptr) string

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
func (x *DBusMessage) GetPath() string {

	cret := xDBusMessageGetPath(x.GoPointer())
	return cret
}

var xDBusMessageGetReplySerial func(uintptr) uint32

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
func (x *DBusMessage) GetReplySerial() uint32 {

	cret := xDBusMessageGetReplySerial(x.GoPointer())
	return cret
}

var xDBusMessageGetSender func(uintptr) string

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
func (x *DBusMessage) GetSender() string {

	cret := xDBusMessageGetSender(x.GoPointer())
	return cret
}

var xDBusMessageGetSerial func(uintptr) uint32

// Gets the serial for @message.
func (x *DBusMessage) GetSerial() uint32 {

	cret := xDBusMessageGetSerial(x.GoPointer())
	return cret
}

var xDBusMessageGetSignature func(uintptr) string

// Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
//
// This will always be non-%NULL, but may be an empty string.
func (x *DBusMessage) GetSignature() string {

	cret := xDBusMessageGetSignature(x.GoPointer())
	return cret
}

var xDBusMessageGetUnixFdList func(uintptr) uintptr

// Gets the UNIX file descriptors associated with @message, if any.
//
// This method is only available on UNIX.
//
// The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
// values in the body of the message. For example,
// if g_variant_get_handle() returns 5, that is intended to be a reference
// to the file descriptor that can be accessed by
// `g_unix_fd_list_get (list, 5, ...)`.
func (x *DBusMessage) GetUnixFdList() *UnixFDList {
	var cls *UnixFDList

	cret := xDBusMessageGetUnixFdList(x.GoPointer())

	if cret == 0 {
		return nil
	}
	gobject.IncreaseRef(cret)
	cls = &UnixFDList{}
	cls.Ptr = cret
	return cls
}

var xDBusMessageLock func(uintptr)

// If @message is locked, does nothing. Otherwise locks the message.
func (x *DBusMessage) Lock() {

	xDBusMessageLock(x.GoPointer())

}

var xDBusMessageNewMethodError func(uintptr, string, string, ...interface{}) uintptr

// Creates a new #GDBusMessage that is an error reply to @method_call_message.
func (x *DBusMessage) NewMethodError(ErrorNameVar string, ErrorMessageFormatVar string, varArgs ...interface{}) *DBusMessage {
	var cls *DBusMessage

	cret := xDBusMessageNewMethodError(x.GoPointer(), ErrorNameVar, ErrorMessageFormatVar, varArgs...)

	if cret == 0 {
		return nil
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	return cls
}

var xDBusMessageNewMethodErrorLiteral func(uintptr, string, string) uintptr

// Creates a new #GDBusMessage that is an error reply to @method_call_message.
func (x *DBusMessage) NewMethodErrorLiteral(ErrorNameVar string, ErrorMessageVar string) *DBusMessage {
	var cls *DBusMessage

	cret := xDBusMessageNewMethodErrorLiteral(x.GoPointer(), ErrorNameVar, ErrorMessageVar)

	if cret == 0 {
		return nil
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	return cls
}

var xDBusMessageNewMethodErrorValist func(uintptr, string, string, []interface{}) uintptr

// Like g_dbus_message_new_method_error() but intended for language bindings.
func (x *DBusMessage) NewMethodErrorValist(ErrorNameVar string, ErrorMessageFormatVar string, VarArgsVar []interface{}) *DBusMessage {
	var cls *DBusMessage

	cret := xDBusMessageNewMethodErrorValist(x.GoPointer(), ErrorNameVar, ErrorMessageFormatVar, VarArgsVar)

	if cret == 0 {
		return nil
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	return cls
}

var xDBusMessageNewMethodReply func(uintptr) uintptr

// Creates a new #GDBusMessage that is a reply to @method_call_message.
func (x *DBusMessage) NewMethodReply() *DBusMessage {
	var cls *DBusMessage

	cret := xDBusMessageNewMethodReply(x.GoPointer())

	if cret == 0 {
		return nil
	}
	cls = &DBusMessage{}
	cls.Ptr = cret
	return cls
}

var xDBusMessagePrint func(uintptr, uint) string

// Produces a human-readable multi-line description of @message.
//
// The contents of the description has no ABI guarantees, the contents
// and formatting is subject to change at any time. Typical output
// looks something like this:
// ```
// Flags:   none
// Version: 0
// Serial:  4
// Headers:
//
//	path -> objectpath '/org/gtk/GDBus/TestObject'
//	interface -> 'org.gtk.GDBus.TestInterface'
//	member -> 'GimmeStdout'
//	destination -> ':1.146'
//
// Body: ()
// UNIX File Descriptors:
//
//	(none)
//
// ```
// or
// ```
// Flags:   no-reply-expected
// Version: 0
// Serial:  477
// Headers:
//
//	reply-serial -> uint32 4
//	destination -> ':1.159'
//	sender -> ':1.146'
//	num-unix-fds -> uint32 1
//
// Body: ()
// UNIX File Descriptors:
//
//	fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
//
// ```
func (x *DBusMessage) Print(IndentVar uint) string {

	cret := xDBusMessagePrint(x.GoPointer(), IndentVar)
	return cret
}

var xDBusMessageSetBody func(uintptr, *glib.Variant)

// Sets the body @message. As a side-effect the
// %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
// type string of @body (or cleared if @body is %NULL).
//
// If @body is floating, @message assumes ownership of @body.
func (x *DBusMessage) SetBody(BodyVar *glib.Variant) {

	xDBusMessageSetBody(x.GoPointer(), BodyVar)

}

var xDBusMessageSetByteOrder func(uintptr, DBusMessageByteOrder)

// Sets the byte order of @message.
func (x *DBusMessage) SetByteOrder(ByteOrderVar DBusMessageByteOrder) {

	xDBusMessageSetByteOrder(x.GoPointer(), ByteOrderVar)

}

var xDBusMessageSetDestination func(uintptr, uintptr)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
func (x *DBusMessage) SetDestination(ValueVar *string) {

	ValueVarPtr := core.GStrdupNullable(ValueVar)
	defer core.GFreeNullable(ValueVarPtr)

	xDBusMessageSetDestination(x.GoPointer(), ValueVarPtr)

}

var xDBusMessageSetErrorName func(uintptr, string)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
func (x *DBusMessage) SetErrorName(ValueVar string) {

	xDBusMessageSetErrorName(x.GoPointer(), ValueVar)

}

var xDBusMessageSetFlags func(uintptr, DBusMessageFlags)

// Sets the flags to set on @message.
func (x *DBusMessage) SetFlags(FlagsVar DBusMessageFlags) {

	xDBusMessageSetFlags(x.GoPointer(), FlagsVar)

}

var xDBusMessageSetHeader func(uintptr, DBusMessageHeaderField, *glib.Variant)

// Sets a header field on @message.
//
// If @value is floating, @message assumes ownership of @value.
func (x *DBusMessage) SetHeader(HeaderFieldVar DBusMessageHeaderField, ValueVar *glib.Variant) {

	xDBusMessageSetHeader(x.GoPointer(), HeaderFieldVar, ValueVar)

}

var xDBusMessageSetInterface func(uintptr, uintptr)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
func (x *DBusMessage) SetInterface(ValueVar *string) {

	ValueVarPtr := core.GStrdupNullable(ValueVar)
	defer core.GFreeNullable(ValueVarPtr)

	xDBusMessageSetInterface(x.GoPointer(), ValueVarPtr)

}

var xDBusMessageSetMember func(uintptr, uintptr)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
func (x *DBusMessage) SetMember(ValueVar *string) {

	ValueVarPtr := core.GStrdupNullable(ValueVar)
	defer core.GFreeNullable(ValueVarPtr)

	xDBusMessageSetMember(x.GoPointer(), ValueVarPtr)

}

var xDBusMessageSetMessageType func(uintptr, DBusMessageType)

// Sets @message to be of @type.
func (x *DBusMessage) SetMessageType(TypeVar DBusMessageType) {

	xDBusMessageSetMessageType(x.GoPointer(), TypeVar)

}

var xDBusMessageSetNumUnixFds func(uintptr, uint32)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
func (x *DBusMessage) SetNumUnixFds(ValueVar uint32) {

	xDBusMessageSetNumUnixFds(x.GoPointer(), ValueVar)

}

var xDBusMessageSetPath func(uintptr, uintptr)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
func (x *DBusMessage) SetPath(ValueVar *string) {

	ValueVarPtr := core.GStrdupNullable(ValueVar)
	defer core.GFreeNullable(ValueVarPtr)

	xDBusMessageSetPath(x.GoPointer(), ValueVarPtr)

}

var xDBusMessageSetReplySerial func(uintptr, uint32)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
func (x *DBusMessage) SetReplySerial(ValueVar uint32) {

	xDBusMessageSetReplySerial(x.GoPointer(), ValueVar)

}

var xDBusMessageSetSender func(uintptr, uintptr)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
func (x *DBusMessage) SetSender(ValueVar *string) {

	ValueVarPtr := core.GStrdupNullable(ValueVar)
	defer core.GFreeNullable(ValueVarPtr)

	xDBusMessageSetSender(x.GoPointer(), ValueVarPtr)

}

var xDBusMessageSetSerial func(uintptr, uint32)

// Sets the serial for @message.
//
// The [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-messages)
// does not allow the @serial to be zero.
func (x *DBusMessage) SetSerial(SerialVar uint32) {

	xDBusMessageSetSerial(x.GoPointer(), SerialVar)

}

var xDBusMessageSetSignature func(uintptr, uintptr)

// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
func (x *DBusMessage) SetSignature(ValueVar *string) {

	ValueVarPtr := core.GStrdupNullable(ValueVar)
	defer core.GFreeNullable(ValueVarPtr)

	xDBusMessageSetSignature(x.GoPointer(), ValueVarPtr)

}

var xDBusMessageSetUnixFdList func(uintptr, uintptr)

// Sets the UNIX file descriptors associated with @message. As a
// side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
// field is set to the number of fds in @fd_list (or cleared if
// @fd_list is %NULL).
//
// This method is only available on UNIX.
//
// When designing D-Bus APIs that are intended to be interoperable,
// please note that non-GDBus implementations of D-Bus can usually only
// access file descriptors if they are referenced by a value of type
// %G_VARIANT_TYPE_HANDLE in the body of the message.
func (x *DBusMessage) SetUnixFdList(FdListVar *UnixFDList) {

	xDBusMessageSetUnixFdList(x.GoPointer(), FdListVar.GoPointer())

}

var xDBusMessageToBlob func(uintptr, *uint, DBusCapabilityFlags, **glib.Error) uintptr

// Serializes @message to a blob. The byte order returned by
// g_dbus_message_get_byte_order() will be used.
func (x *DBusMessage) ToBlob(OutSizeVar *uint, CapabilitiesVar DBusCapabilityFlags) (uintptr, error) {
	var cerr *glib.Error

	cret := xDBusMessageToBlob(x.GoPointer(), OutSizeVar, CapabilitiesVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xDBusMessageToGerror func(uintptr) bool

// If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
// nothing and returns %FALSE.
//
// Otherwise this method encodes the error in @message as a #GError
// using g_dbus_error_set_dbus_error() using the information in the
// %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
// well as the first string item in @message's body.
func (x *DBusMessage) ToGerror() (bool, error) {
	var cerr *glib.Error

	cret := xDBusMessageToGerror(x.GoPointer())
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

func (c *DBusMessage) GoPointer() uintptr {
	if c == nil {
		return 0
	}
	return c.Ptr
}

func (c *DBusMessage) SetGoPointer(ptr uintptr) {
	c.Ptr = ptr
}

// GetPropertyLocked gets the "locked" property.
func (x *DBusMessage) GetPropertyLocked() bool {
	var v gobject.Value
	x.GetProperty("locked", &v)
	return v.GetBoolean()
}

var xDBusMessageBytesNeeded func([]byte, uint, **glib.Error) int

// Utility function to calculate how many bytes are needed to
// completely deserialize the D-Bus message stored at @blob.
func DBusMessageBytesNeeded(BlobVar []byte, BlobLenVar uint) (int, error) {
	var cerr *glib.Error

	cret := xDBusMessageBytesNeeded(BlobVar, BlobLenVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

func init() {
	core.SetPackageName("GIO", "gio-2.0")
	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GIO") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xDBusMessageGLibType, libs, "g_dbus_message_get_type")

	core.PuregoSafeRegister(&xNewDBusMessage, libs, "g_dbus_message_new")
	core.PuregoSafeRegister(&xNewDBusMessageFromBlob, libs, "g_dbus_message_new_from_blob")
	core.PuregoSafeRegister(&xNewDBusMessageMethodCall, libs, "g_dbus_message_new_method_call")
	core.PuregoSafeRegister(&xNewDBusMessageSignal, libs, "g_dbus_message_new_signal")

	core.PuregoSafeRegister(&xDBusMessageCopy, libs, "g_dbus_message_copy")
	core.PuregoSafeRegister(&xDBusMessageGetArg0, libs, "g_dbus_message_get_arg0")
	core.PuregoSafeRegister(&xDBusMessageGetArg0Path, libs, "g_dbus_message_get_arg0_path")
	core.PuregoSafeRegister(&xDBusMessageGetBody, libs, "g_dbus_message_get_body")
	core.PuregoSafeRegister(&xDBusMessageGetByteOrder, libs, "g_dbus_message_get_byte_order")
	core.PuregoSafeRegister(&xDBusMessageGetDestination, libs, "g_dbus_message_get_destination")
	core.PuregoSafeRegister(&xDBusMessageGetErrorName, libs, "g_dbus_message_get_error_name")
	core.PuregoSafeRegister(&xDBusMessageGetFlags, libs, "g_dbus_message_get_flags")
	core.PuregoSafeRegister(&xDBusMessageGetHeader, libs, "g_dbus_message_get_header")
	core.PuregoSafeRegister(&xDBusMessageGetHeaderFields, libs, "g_dbus_message_get_header_fields")
	core.PuregoSafeRegister(&xDBusMessageGetInterface, libs, "g_dbus_message_get_interface")
	core.PuregoSafeRegister(&xDBusMessageGetLocked, libs, "g_dbus_message_get_locked")
	core.PuregoSafeRegister(&xDBusMessageGetMember, libs, "g_dbus_message_get_member")
	core.PuregoSafeRegister(&xDBusMessageGetMessageType, libs, "g_dbus_message_get_message_type")
	core.PuregoSafeRegister(&xDBusMessageGetNumUnixFds, libs, "g_dbus_message_get_num_unix_fds")
	core.PuregoSafeRegister(&xDBusMessageGetPath, libs, "g_dbus_message_get_path")
	core.PuregoSafeRegister(&xDBusMessageGetReplySerial, libs, "g_dbus_message_get_reply_serial")
	core.PuregoSafeRegister(&xDBusMessageGetSender, libs, "g_dbus_message_get_sender")
	core.PuregoSafeRegister(&xDBusMessageGetSerial, libs, "g_dbus_message_get_serial")
	core.PuregoSafeRegister(&xDBusMessageGetSignature, libs, "g_dbus_message_get_signature")
	core.PuregoSafeRegister(&xDBusMessageGetUnixFdList, libs, "g_dbus_message_get_unix_fd_list")
	core.PuregoSafeRegister(&xDBusMessageLock, libs, "g_dbus_message_lock")
	core.PuregoSafeRegister(&xDBusMessageNewMethodError, libs, "g_dbus_message_new_method_error")
	core.PuregoSafeRegister(&xDBusMessageNewMethodErrorLiteral, libs, "g_dbus_message_new_method_error_literal")
	core.PuregoSafeRegister(&xDBusMessageNewMethodErrorValist, libs, "g_dbus_message_new_method_error_valist")
	core.PuregoSafeRegister(&xDBusMessageNewMethodReply, libs, "g_dbus_message_new_method_reply")
	core.PuregoSafeRegister(&xDBusMessagePrint, libs, "g_dbus_message_print")
	core.PuregoSafeRegister(&xDBusMessageSetBody, libs, "g_dbus_message_set_body")
	core.PuregoSafeRegister(&xDBusMessageSetByteOrder, libs, "g_dbus_message_set_byte_order")
	core.PuregoSafeRegister(&xDBusMessageSetDestination, libs, "g_dbus_message_set_destination")
	core.PuregoSafeRegister(&xDBusMessageSetErrorName, libs, "g_dbus_message_set_error_name")
	core.PuregoSafeRegister(&xDBusMessageSetFlags, libs, "g_dbus_message_set_flags")
	core.PuregoSafeRegister(&xDBusMessageSetHeader, libs, "g_dbus_message_set_header")
	core.PuregoSafeRegister(&xDBusMessageSetInterface, libs, "g_dbus_message_set_interface")
	core.PuregoSafeRegister(&xDBusMessageSetMember, libs, "g_dbus_message_set_member")
	core.PuregoSafeRegister(&xDBusMessageSetMessageType, libs, "g_dbus_message_set_message_type")
	core.PuregoSafeRegister(&xDBusMessageSetNumUnixFds, libs, "g_dbus_message_set_num_unix_fds")
	core.PuregoSafeRegister(&xDBusMessageSetPath, libs, "g_dbus_message_set_path")
	core.PuregoSafeRegister(&xDBusMessageSetReplySerial, libs, "g_dbus_message_set_reply_serial")
	core.PuregoSafeRegister(&xDBusMessageSetSender, libs, "g_dbus_message_set_sender")
	core.PuregoSafeRegister(&xDBusMessageSetSerial, libs, "g_dbus_message_set_serial")
	core.PuregoSafeRegister(&xDBusMessageSetSignature, libs, "g_dbus_message_set_signature")
	core.PuregoSafeRegister(&xDBusMessageSetUnixFdList, libs, "g_dbus_message_set_unix_fd_list")
	core.PuregoSafeRegister(&xDBusMessageToBlob, libs, "g_dbus_message_to_blob")
	core.PuregoSafeRegister(&xDBusMessageToGerror, libs, "g_dbus_message_to_gerror")

	core.PuregoSafeRegister(&xDBusMessageBytesNeeded, libs, "g_dbus_message_bytes_needed")

}