/*This file is automatically generated by pkg.deepin.io/dbus-generator. Don't edit it*/
package networkmanager

import "pkg.deepin.io/lib/dbus"
import "pkg.deepin.io/lib/dbus/property"
import "reflect"
import "sync"
import "runtime"
import "fmt"
import "errors"

/*prevent compile error*/
var _ = fmt.Println
var _ = runtime.SetFinalizer
var _ = sync.NewCond
var _ = reflect.TypeOf
var _ = property.BaseObserver{}

type ActiveConnection struct {
	Path     dbus.ObjectPath
	DestName string
	core     *dbus.Object

	signals       map[<-chan *dbus.Signal]struct{}
	signalsLocker sync.Mutex

	Connection     *dbusPropertyActiveConnectionConnection
	SpecificObject *dbusPropertyActiveConnectionSpecificObject
	Id             *dbusPropertyActiveConnectionId
	Uuid           *dbusPropertyActiveConnectionUuid
	Type           *dbusPropertyActiveConnectionType
	Devices        *dbusPropertyActiveConnectionDevices
	State          *dbusPropertyActiveConnectionState
	Default        *dbusPropertyActiveConnectionDefault
	Ip4Config      *dbusPropertyActiveConnectionIp4Config
	Dhcp4Config    *dbusPropertyActiveConnectionDhcp4Config
	Default6       *dbusPropertyActiveConnectionDefault6
	Ip6Config      *dbusPropertyActiveConnectionIp6Config
	Dhcp6Config    *dbusPropertyActiveConnectionDhcp6Config
	Vpn            *dbusPropertyActiveConnectionVpn
	Master         *dbusPropertyActiveConnectionMaster
}

func (obj *ActiveConnection) _createSignalChan() <-chan *dbus.Signal {
	obj.signalsLocker.Lock()
	ch := getBus().Signal()
	obj.signals[ch] = struct{}{}
	obj.signalsLocker.Unlock()
	return ch
}
func (obj *ActiveConnection) _deleteSignalChan(ch <-chan *dbus.Signal) {
	obj.signalsLocker.Lock()
	delete(obj.signals, ch)
	getBus().DetachSignal(ch)
	obj.signalsLocker.Unlock()
}
func DestroyActiveConnection(obj *ActiveConnection) {
	obj.signalsLocker.Lock()
	defer obj.signalsLocker.Unlock()
	if obj.signals == nil {
		return
	}
	for ch, _ := range obj.signals {
		getBus().DetachSignal(ch)
	}
	obj.signals = nil

	runtime.SetFinalizer(obj, nil)

	dbusRemoveMatch("type='signal',path='" + string(obj.Path) + "',interface='org.freedesktop.DBus.Properties',sender='" + obj.DestName + "',member='PropertiesChanged'")
	dbusRemoveMatch("type='signal',path='" + string(obj.Path) + "',interface='org.freedesktop.NetworkManager.Connection.Active',sender='" + obj.DestName + "',member='PropertiesChanged'")

	dbusRemoveMatch("type='signal',path='" + string(obj.Path) + "',interface='org.freedesktop.NetworkManager.Connection.Active',sender='" + obj.DestName + "',member='PropertiesChanged'")

	obj.Connection.Reset()
	obj.SpecificObject.Reset()
	obj.Id.Reset()
	obj.Uuid.Reset()
	obj.Type.Reset()
	obj.Devices.Reset()
	obj.State.Reset()
	obj.Default.Reset()
	obj.Ip4Config.Reset()
	obj.Dhcp4Config.Reset()
	obj.Default6.Reset()
	obj.Ip6Config.Reset()
	obj.Dhcp6Config.Reset()
	obj.Vpn.Reset()
	obj.Master.Reset()
}

func (obj *ActiveConnection) ConnectPropertiesChanged(callback func(properties map[string]dbus.Variant)) func() {
	sigChan := obj._createSignalChan()
	go func() {
		for v := range sigChan {
			if v.Path != obj.Path || v.Name != "org.freedesktop.NetworkManager.Connection.Active.PropertiesChanged" || 1 != len(v.Body) {
				continue
			}
			if reflect.TypeOf(v.Body[0]) != reflect.TypeOf((*map[string]dbus.Variant)(nil)).Elem() {
				continue
			}

			callback(v.Body[0].(map[string]dbus.Variant))
		}
	}()
	return func() {
		obj._deleteSignalChan(sigChan)
	}
}

type dbusPropertyActiveConnectionConnection struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionConnection) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Connection is not writable")
}

func (this *dbusPropertyActiveConnectionConnection) Get() dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.(dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionConnection) GetValue() (interface{} /*dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Connection").Store(&r)
	if err == nil && r.Signature().String() == "o" {
		return r.Value().(dbus.ObjectPath), nil
	}
	return *new(dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionConnection) GetType() reflect.Type {
	return reflect.TypeOf((*dbus.ObjectPath)(nil)).Elem()
}

type dbusPropertyActiveConnectionSpecificObject struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionSpecificObject) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.SpecificObject is not writable")
}

func (this *dbusPropertyActiveConnectionSpecificObject) Get() dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.(dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionSpecificObject) GetValue() (interface{} /*dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "SpecificObject").Store(&r)
	if err == nil && r.Signature().String() == "o" {
		return r.Value().(dbus.ObjectPath), nil
	}
	return *new(dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionSpecificObject) GetType() reflect.Type {
	return reflect.TypeOf((*dbus.ObjectPath)(nil)).Elem()
}

type dbusPropertyActiveConnectionId struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionId) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Id is not writable")
}

func (this *dbusPropertyActiveConnectionId) Get() string {
	v, _ := this.GetValue()
	return v.(string)
}
func (this *dbusPropertyActiveConnectionId) GetValue() (interface{} /*string*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Id").Store(&r)
	if err == nil && r.Signature().String() == "s" {
		return r.Value().(string), nil
	}
	return *new(string), err
}
func (this *dbusPropertyActiveConnectionId) GetType() reflect.Type {
	return reflect.TypeOf((*string)(nil)).Elem()
}

type dbusPropertyActiveConnectionUuid struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionUuid) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Uuid is not writable")
}

func (this *dbusPropertyActiveConnectionUuid) Get() string {
	v, _ := this.GetValue()
	return v.(string)
}
func (this *dbusPropertyActiveConnectionUuid) GetValue() (interface{} /*string*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Uuid").Store(&r)
	if err == nil && r.Signature().String() == "s" {
		return r.Value().(string), nil
	}
	return *new(string), err
}
func (this *dbusPropertyActiveConnectionUuid) GetType() reflect.Type {
	return reflect.TypeOf((*string)(nil)).Elem()
}

type dbusPropertyActiveConnectionType struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionType) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Type is not writable")
}

func (this *dbusPropertyActiveConnectionType) Get() string {
	v, _ := this.GetValue()
	return v.(string)
}
func (this *dbusPropertyActiveConnectionType) GetValue() (interface{} /*string*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Type").Store(&r)
	if err == nil && r.Signature().String() == "s" {
		return r.Value().(string), nil
	}
	return *new(string), err
}
func (this *dbusPropertyActiveConnectionType) GetType() reflect.Type {
	return reflect.TypeOf((*string)(nil)).Elem()
}

type dbusPropertyActiveConnectionDevices struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionDevices) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Devices is not writable")
}

func (this *dbusPropertyActiveConnectionDevices) Get() []dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.([]dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionDevices) GetValue() (interface{} /*[]dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Devices").Store(&r)
	if err == nil && r.Signature().String() == "ao" {
		return r.Value().([]dbus.ObjectPath), nil
	}
	return *new([]dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionDevices) GetType() reflect.Type {
	return reflect.TypeOf((*[]dbus.ObjectPath)(nil)).Elem()
}

type dbusPropertyActiveConnectionState struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionState) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.State is not writable")
}

func (this *dbusPropertyActiveConnectionState) Get() uint32 {
	v, _ := this.GetValue()
	return v.(uint32)
}
func (this *dbusPropertyActiveConnectionState) GetValue() (interface{} /*uint32*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "State").Store(&r)
	if err == nil && r.Signature().String() == "u" {
		return r.Value().(uint32), nil
	}
	return *new(uint32), err
}
func (this *dbusPropertyActiveConnectionState) GetType() reflect.Type {
	return reflect.TypeOf((*uint32)(nil)).Elem()
}

type dbusPropertyActiveConnectionDefault struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionDefault) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Default is not writable")
}

func (this *dbusPropertyActiveConnectionDefault) Get() bool {
	v, _ := this.GetValue()
	return v.(bool)
}
func (this *dbusPropertyActiveConnectionDefault) GetValue() (interface{} /*bool*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Default").Store(&r)
	if err == nil && r.Signature().String() == "b" {
		return r.Value().(bool), nil
	}
	return *new(bool), err
}
func (this *dbusPropertyActiveConnectionDefault) GetType() reflect.Type {
	return reflect.TypeOf((*bool)(nil)).Elem()
}

type dbusPropertyActiveConnectionIp4Config struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionIp4Config) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Ip4Config is not writable")
}

func (this *dbusPropertyActiveConnectionIp4Config) Get() dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.(dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionIp4Config) GetValue() (interface{} /*dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Ip4Config").Store(&r)
	if err == nil && r.Signature().String() == "o" {
		return r.Value().(dbus.ObjectPath), nil
	}
	return *new(dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionIp4Config) GetType() reflect.Type {
	return reflect.TypeOf((*dbus.ObjectPath)(nil)).Elem()
}

type dbusPropertyActiveConnectionDhcp4Config struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionDhcp4Config) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Dhcp4Config is not writable")
}

func (this *dbusPropertyActiveConnectionDhcp4Config) Get() dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.(dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionDhcp4Config) GetValue() (interface{} /*dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Dhcp4Config").Store(&r)
	if err == nil && r.Signature().String() == "o" {
		return r.Value().(dbus.ObjectPath), nil
	}
	return *new(dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionDhcp4Config) GetType() reflect.Type {
	return reflect.TypeOf((*dbus.ObjectPath)(nil)).Elem()
}

type dbusPropertyActiveConnectionDefault6 struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionDefault6) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Default6 is not writable")
}

func (this *dbusPropertyActiveConnectionDefault6) Get() bool {
	v, _ := this.GetValue()
	return v.(bool)
}
func (this *dbusPropertyActiveConnectionDefault6) GetValue() (interface{} /*bool*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Default6").Store(&r)
	if err == nil && r.Signature().String() == "b" {
		return r.Value().(bool), nil
	}
	return *new(bool), err
}
func (this *dbusPropertyActiveConnectionDefault6) GetType() reflect.Type {
	return reflect.TypeOf((*bool)(nil)).Elem()
}

type dbusPropertyActiveConnectionIp6Config struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionIp6Config) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Ip6Config is not writable")
}

func (this *dbusPropertyActiveConnectionIp6Config) Get() dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.(dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionIp6Config) GetValue() (interface{} /*dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Ip6Config").Store(&r)
	if err == nil && r.Signature().String() == "o" {
		return r.Value().(dbus.ObjectPath), nil
	}
	return *new(dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionIp6Config) GetType() reflect.Type {
	return reflect.TypeOf((*dbus.ObjectPath)(nil)).Elem()
}

type dbusPropertyActiveConnectionDhcp6Config struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionDhcp6Config) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Dhcp6Config is not writable")
}

func (this *dbusPropertyActiveConnectionDhcp6Config) Get() dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.(dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionDhcp6Config) GetValue() (interface{} /*dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Dhcp6Config").Store(&r)
	if err == nil && r.Signature().String() == "o" {
		return r.Value().(dbus.ObjectPath), nil
	}
	return *new(dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionDhcp6Config) GetType() reflect.Type {
	return reflect.TypeOf((*dbus.ObjectPath)(nil)).Elem()
}

type dbusPropertyActiveConnectionVpn struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionVpn) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Vpn is not writable")
}

func (this *dbusPropertyActiveConnectionVpn) Get() bool {
	v, _ := this.GetValue()
	return v.(bool)
}
func (this *dbusPropertyActiveConnectionVpn) GetValue() (interface{} /*bool*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Vpn").Store(&r)
	if err == nil && r.Signature().String() == "b" {
		return r.Value().(bool), nil
	}
	return *new(bool), err
}
func (this *dbusPropertyActiveConnectionVpn) GetType() reflect.Type {
	return reflect.TypeOf((*bool)(nil)).Elem()
}

type dbusPropertyActiveConnectionMaster struct {
	*property.BaseObserver
	core *dbus.Object
}

func (this *dbusPropertyActiveConnectionMaster) SetValue(notwritable interface{}) {
	fmt.Println("org.freedesktop.NetworkManager.Connection.Active.Master is not writable")
}

func (this *dbusPropertyActiveConnectionMaster) Get() dbus.ObjectPath {
	v, _ := this.GetValue()
	return v.(dbus.ObjectPath)
}
func (this *dbusPropertyActiveConnectionMaster) GetValue() (interface{} /*dbus.ObjectPath*/, error) {
	var r dbus.Variant
	err := this.core.Call("org.freedesktop.DBus.Properties.Get", 0, "org.freedesktop.NetworkManager.Connection.Active", "Master").Store(&r)
	if err == nil && r.Signature().String() == "o" {
		return r.Value().(dbus.ObjectPath), nil
	}
	return *new(dbus.ObjectPath), err
}
func (this *dbusPropertyActiveConnectionMaster) GetType() reflect.Type {
	return reflect.TypeOf((*dbus.ObjectPath)(nil)).Elem()
}

func NewActiveConnection(destName string, path dbus.ObjectPath) (*ActiveConnection, error) {
	if !path.IsValid() {
		return nil, errors.New("The path of '" + string(path) + "' is invalid.")
	}

	core := getBus().Object(destName, path)

	obj := &ActiveConnection{Path: path, DestName: destName, core: core, signals: make(map[<-chan *dbus.Signal]struct{})}

	obj.Connection = &dbusPropertyActiveConnectionConnection{&property.BaseObserver{}, core}
	obj.SpecificObject = &dbusPropertyActiveConnectionSpecificObject{&property.BaseObserver{}, core}
	obj.Id = &dbusPropertyActiveConnectionId{&property.BaseObserver{}, core}
	obj.Uuid = &dbusPropertyActiveConnectionUuid{&property.BaseObserver{}, core}
	obj.Type = &dbusPropertyActiveConnectionType{&property.BaseObserver{}, core}
	obj.Devices = &dbusPropertyActiveConnectionDevices{&property.BaseObserver{}, core}
	obj.State = &dbusPropertyActiveConnectionState{&property.BaseObserver{}, core}
	obj.Default = &dbusPropertyActiveConnectionDefault{&property.BaseObserver{}, core}
	obj.Ip4Config = &dbusPropertyActiveConnectionIp4Config{&property.BaseObserver{}, core}
	obj.Dhcp4Config = &dbusPropertyActiveConnectionDhcp4Config{&property.BaseObserver{}, core}
	obj.Default6 = &dbusPropertyActiveConnectionDefault6{&property.BaseObserver{}, core}
	obj.Ip6Config = &dbusPropertyActiveConnectionIp6Config{&property.BaseObserver{}, core}
	obj.Dhcp6Config = &dbusPropertyActiveConnectionDhcp6Config{&property.BaseObserver{}, core}
	obj.Vpn = &dbusPropertyActiveConnectionVpn{&property.BaseObserver{}, core}
	obj.Master = &dbusPropertyActiveConnectionMaster{&property.BaseObserver{}, core}

	dbusAddMatch("type='signal',path='" + string(path) + "',interface='org.freedesktop.DBus.Properties',sender='" + destName + "',member='PropertiesChanged'")
	dbusAddMatch("type='signal',path='" + string(path) + "',interface='org.freedesktop.NetworkManager.Connection.Active',sender='" + destName + "',member='PropertiesChanged'")
	sigChan := obj._createSignalChan()
	go func() {
		typeString := reflect.TypeOf("")
		typeKeyValues := reflect.TypeOf(map[string]dbus.Variant{})
		typeArrayValues := reflect.TypeOf([]string{})
		for v := range sigChan {
			if v.Name == "org.freedesktop.DBus.Properties.PropertiesChanged" &&
				len(v.Body) == 3 &&
				reflect.TypeOf(v.Body[0]) == typeString &&
				reflect.TypeOf(v.Body[1]) == typeKeyValues &&
				reflect.TypeOf(v.Body[2]) == typeArrayValues &&
				v.Body[0].(string) == "org.freedesktop.NetworkManager.Connection.Active" {
				props := v.Body[1].(map[string]dbus.Variant)
				for key, _ := range props {
					if false {
					} else if key == "Connection" {
						obj.Connection.Notify()

					} else if key == "SpecificObject" {
						obj.SpecificObject.Notify()

					} else if key == "Id" {
						obj.Id.Notify()

					} else if key == "Uuid" {
						obj.Uuid.Notify()

					} else if key == "Type" {
						obj.Type.Notify()

					} else if key == "Devices" {
						obj.Devices.Notify()

					} else if key == "State" {
						obj.State.Notify()

					} else if key == "Default" {
						obj.Default.Notify()

					} else if key == "Ip4Config" {
						obj.Ip4Config.Notify()

					} else if key == "Dhcp4Config" {
						obj.Dhcp4Config.Notify()

					} else if key == "Default6" {
						obj.Default6.Notify()

					} else if key == "Ip6Config" {
						obj.Ip6Config.Notify()

					} else if key == "Dhcp6Config" {
						obj.Dhcp6Config.Notify()

					} else if key == "Vpn" {
						obj.Vpn.Notify()

					} else if key == "Master" {
						obj.Master.Notify()
					}
				}
			} else if v.Name == "org.freedesktop.NetworkManager.Connection.Active.PropertiesChanged" && len(v.Body) == 1 && reflect.TypeOf(v.Body[0]) == typeKeyValues {
				for key, _ := range v.Body[0].(map[string]dbus.Variant) {
					if false {
					} else if key == "Connection" {
						obj.Connection.Notify()

					} else if key == "SpecificObject" {
						obj.SpecificObject.Notify()

					} else if key == "Id" {
						obj.Id.Notify()

					} else if key == "Uuid" {
						obj.Uuid.Notify()

					} else if key == "Type" {
						obj.Type.Notify()

					} else if key == "Devices" {
						obj.Devices.Notify()

					} else if key == "State" {
						obj.State.Notify()

					} else if key == "Default" {
						obj.Default.Notify()

					} else if key == "Ip4Config" {
						obj.Ip4Config.Notify()

					} else if key == "Dhcp4Config" {
						obj.Dhcp4Config.Notify()

					} else if key == "Default6" {
						obj.Default6.Notify()

					} else if key == "Ip6Config" {
						obj.Ip6Config.Notify()

					} else if key == "Dhcp6Config" {
						obj.Dhcp6Config.Notify()

					} else if key == "Vpn" {
						obj.Vpn.Notify()

					} else if key == "Master" {
						obj.Master.Notify()
					}
				}
			}
		}
	}()

	dbusAddMatch("type='signal',path='" + string(obj.Path) + "',interface='org.freedesktop.NetworkManager.Connection.Active',sender='" + obj.DestName + "',member='PropertiesChanged'")

	runtime.SetFinalizer(obj, func(_obj *ActiveConnection) { DestroyActiveConnection(_obj) })
	return obj, nil
}
